mobioffice-cli 0.0.1

package/src/models/attendance.model.ts

@@ -0,0 +1,615 @@
+import * as admin from "firebase-admin";
+import { Action } from "./action.model";
+import { Company } from "./company.model";
+import { License } from "./license.model";
+import { User } from "./user.model";
+import { Utilities } from "./utility.model";
+import { Pool } from 'mysql2';
+import CurdService from "./crud/crud";
+
+class Attendance {
+  static async getAttendancebyUser(
+    firestore: admin.firestore.Firestore,
+    company: string,
+    phone: string,
+    from_date: string,
+    to_date: string,
+    isOnlyMonthRequired: boolean
+  ) {
+    console.log("in getAttendance by user");
+    console.log(from_date, to_date);
+    let epochFromDate = await Attendance.convertToTimestamp(from_date);
+    let epochToDate = await License.convertDatetoTimestamp(to_date);
+    let datesInMonthList = await Attendance.getDatesInInterval(
+      from_date,
+      to_date,
+      isOnlyMonthRequired
+    );
+    let userStartAtDoc: any = Array.apply(
+      null,
+      Array(datesInMonthList.length)
+    ).map(() => {
+      return [];
+    });
+    let userEndAtDoc: any = Array.apply(
+      null,
+      Array(datesInMonthList.length)
+    ).map(() => {
+      return [];
+    });
+    let userId = await User.getUserIdByPhone(firestore, phone);
+    let companyId = await Company.getCompanyIdByNickName(firestore, company);
+    let actionId = await Action.getActionId(
+      firestore,
+      companyId,
+      "check_in_out"
+    );
+    if (!actionId) {
+      return { data: datesInMonthList, message: "action" };
+    }
+    let userAttendance_snapshot = await Attendance.getAttendancefromFirestore(
+      firestore,
+      companyId,
+      actionId,
+      userId,
+      epochFromDate,
+      epochToDate
+    );
+    if (userAttendance_snapshot.empty) {
+      return { data: datesInMonthList, message: "data not found" };
+    }
+    userAttendance_snapshot.forEach((doc) => {
+      if (
+        epochFromDate <= doc.data().startAt &&
+        doc.data().startAt <= epochToDate
+      ) {
+        let startAt = new Date(doc.data().startAt).toLocaleString("en-GB", {
+          year: "numeric",
+          month: "numeric",
+          day: "numeric",
+          hour: "2-digit",
+          minute: "2-digit",
+        });
+        let idx: number = parseInt(startAt.split(",")[0].split("/")[0]) - 1;
+        userStartAtDoc[idx].push(startAt.replace(",", ""));
+      } else if (
+        epochFromDate <= doc.data().endAt &&
+        doc.data().endAt <= epochToDate
+      ) {
+        let endAt = new Date(doc.data().endAt).toLocaleString("en-GB", {
+          year: "numeric",
+          month: "numeric",
+          day: "numeric",
+          hour: "2-digit",
+          minute: "2-digit",
+        });
+        let idx: number = parseInt(endAt.split(",")[0].split("/")[0]) - 1;
+        userEndAtDoc[idx].push(endAt.replace(",", ""));
+      }
+    });
+    for (let date in datesInMonthList) {
+      let startAt = userStartAtDoc[date][userStartAtDoc[date].length - 1]
+        ? userStartAtDoc[date][userStartAtDoc[date].length - 1]
+        : "";
+      let endAt = userEndAtDoc[date][0] ? userEndAtDoc[date][0] : "";
+      Object.assign(datesInMonthList[date], { in: startAt }, { status: null });
+      Object.assign(datesInMonthList[date], { out: endAt }, { status: null });
+    }
+    return { data: datesInMonthList, message: "Success" };
+  }
+
+  static async getByDateAttendancebyUser(
+    firestore: admin.firestore.Firestore,
+    company: string,
+    phone: string,
+    from_date: string,
+    to_date: string
+  ) {
+    let epochFromDate = await Attendance.convertToTimestamp(from_date);
+    let epochToDate = await License.convertDatetoTimestamp(to_date);
+    let attendanceObj = {
+      "In Time": "",
+      "Out Time": "",
+    };
+    let userStartAt: any = "";
+    let userEndAt: any = "";
+    let userId = await User.getUserIdByPhone(firestore, phone);
+    let companyId = await Company.getCompanyIdByNickName(firestore, company);
+    let actionId = await Action.getActionId(
+      firestore,
+      companyId,
+      "check_in_out"
+    );
+    if (!actionId) {
+      return { data: attendanceObj, message: "No action" };
+    }
+    let userAttendance_snapshot = await Attendance.getAttendancefromFirestore(
+      firestore,
+      companyId,
+      actionId,
+      userId,
+      epochFromDate,
+      epochToDate
+    );
+    if (userAttendance_snapshot.empty) {
+      return { data: attendanceObj, message: "Data not found" };
+    }
+    userAttendance_snapshot.forEach((doc) => {
+      console.log("before if condition", epochFromDate, doc.data().startAt);
+      if (
+        epochFromDate <= doc.data().startAt &&
+        doc.data().startAt <= epochToDate
+      ) {
+        console.log(epochFromDate, doc.data().startAt);
+        let startAt = new Date(doc.data().startAt).toLocaleString("en-GB", {
+          year: "numeric",
+          month: "numeric",
+          day: "numeric",
+          hour: "2-digit",
+          minute: "2-digit",
+        });
+        userStartAt = startAt.replace(",", "").split(" ")[1];
+        console.log(userStartAt);
+      } else if (
+        epochFromDate <= doc.data().endAt &&
+        doc.data().endAt <= epochToDate
+      ) {
+        let endAt = new Date(doc.data().endAt).toLocaleString("en-GB", {
+          year: "numeric",
+          month: "numeric",
+          day: "numeric",
+          hour: "2-digit",
+          minute: "2-digit",
+        });
+        userEndAt = endAt.replace(",", "").split(" ")[1];
+      }
+    });
+    console.log("startAt", userStartAt);
+    console.log("endAt", userEndAt);
+    attendanceObj["In Time"] = userStartAt;
+    attendanceObj["Out Time"] = userEndAt;
+    return { data: attendanceObj, message: "Success" };
+  }
+
+  static async getDatesInMonth(date: string, from_date?: string) {
+    console.log("here", date, from_date);
+    let startDate;
+    const endDate = Number(date.split("-")[0]);
+    if (from_date) {
+      startDate = Number(from_date.split("-")[0]);
+    } else {
+      startDate = 1;
+    }
+    let month = date.split("-")[1];
+    let year = date.split("-")[2];
+    let getDatesInMonth: object[] = [];
+    // let daysinmonth = new Date(parseInt(year), parseInt(month),0).getDate();
+    for (startDate; startDate <= endDate; startDate++) {
+      getDatesInMonth.push({
+        date: `${String(startDate).padStart(2, "0")}/${month}/${year}`,
+        in: "",
+        out: "",
+        status: "",
+      });
+    }
+    console.log(getDatesInMonth);
+    return getDatesInMonth;
+  }
+
+  static async getDatesInInterval(
+    startDate: string,
+    endDate: string,
+    isOnlyMonthRequired: boolean
+  ) {
+    if (isOnlyMonthRequired) {
+      return this.getDaysOfMonth(startDate, endDate);
+    }
+    console.log(startDate, endDate);
+    const startYear = Number(startDate.split("-")[2]);
+    const startMonth = Number(startDate.split("-")[1]);
+    const startDay = Number(startDate.split("-")[0]);
+    const endYear = Number(endDate.split("-")[2]);
+    const endMonth = Number(endDate.split("-")[1]);
+    const endDay = Number(endDate.split("-")[0]);
+    let datesInInterval: any[] = [];
+    for (let i = startYear; i <= endYear; i++) {
+      console.log("year", i);
+      const currentYear = i;
+      const isStartYear = this.isStartYear(currentYear, startYear);
+      const isEndYear = this.isEndYear(currentYear, endYear);
+      if (isStartYear && isEndYear) {
+        console.log("only year");
+        const daysOfYear = this.getDaysOfYear(
+          i,
+          startMonth,
+          endMonth,
+          startDay,
+          endDay,
+          "onlyYear"
+        );
+        datesInInterval = [...datesInInterval, ...daysOfYear];
+      } else if (isStartYear) {
+        console.log("start year");
+        const daysOfYear = this.getDaysOfYear(
+          i,
+          startMonth,
+          12,
+          startDay,
+          endDay,
+          "startYear"
+        );
+        datesInInterval = [...datesInInterval, ...daysOfYear];
+      } else if (isEndYear) {
+        console.log("end year");
+        const daysOfYear = this.getDaysOfYear(
+          i,
+          1,
+          endMonth,
+          startDay,
+          endDay,
+          "endYear"
+        );
+        datesInInterval = [...datesInInterval, ...daysOfYear];
+      } else {
+        console.log("middle year");
+        const daysOfYear = this.getDaysOfYear(
+          i,
+          1,
+          12,
+          startDay,
+          endDay,
+          "middleYear"
+        );
+        datesInInterval = [...datesInInterval, ...daysOfYear];
+      }
+    }
+    console.log(datesInInterval);
+    return datesInInterval;
+  }
+
+  static isStartMonth(currMonth: number, startMonth: number) {
+    return currMonth === startMonth;
+  }
+
+  static isEndMonth(currMonth: number, endMonth: number) {
+    return currMonth === endMonth;
+  }
+
+  static isStartYear(currYear: number, startYear: number) {
+    return currYear === startYear;
+  }
+
+  static isEndYear(currYear: number, endYear: number) {
+    return currYear === endYear;
+  }
+
+  static getDaysOfYear(
+    year: number,
+    startMonth: number,
+    endMonth: number,
+    startDay: number,
+    endDay: number,
+    yearType: string
+  ) {
+    let datesOfYear: any[] = [];
+    console.log(startMonth, endMonth);
+    for (let j = startMonth; j < endMonth + 1; j++) {
+      console.log("currMonth", j);
+      const isStartMonth = this.isStartMonth(j, startMonth);
+      const isEndMonth = this.isEndMonth(j, endMonth);
+      console.log("isStartMonth", isStartMonth);
+      console.log("isEndMonth", isEndMonth);
+      if (isStartMonth && isEndMonth && yearType === "onlyYear") {
+        console.log("only month");
+        const from_date = `${startDay}-${j}-${year}`;
+        const to_date = `${endDay}-${j}-${year}`;
+        const daysOfMonth = this.getDaysOfMonth(from_date, to_date);
+        datesOfYear = [...datesOfYear, ...daysOfMonth];
+      } else if (
+        isStartMonth &&
+        (yearType === "startYear" || yearType === "onlyYear")
+      ) {
+        console.log("start month");
+        const from_date = `${startDay}-${j}-${year}`;
+        const lastDateOfMonth = new Date(year, j, 0).getDate();
+        const to_date = `${lastDateOfMonth}-${j}-${year}`;
+        const daysOfMonth = this.getDaysOfMonth(from_date, to_date);
+        datesOfYear = [...datesOfYear, ...daysOfMonth];
+      } else if (
+        isEndMonth &&
+        (yearType === "endYear" || yearType === "onlyYear")
+      ) {
+        console.log("last month");
+        const from_date = `${1}-${j}-${year}`;
+        const to_date = `${endDay}-${j}-${year}`;
+        const daysOfMonth = this.getDaysOfMonth(from_date, to_date);
+        datesOfYear = [...datesOfYear, ...daysOfMonth];
+      } else {
+        console.log("middle month");
+        const from_date = `${1}-${j}-${year}`;
+        const lastDateOfMonth = new Date(year, j, 0).getDate();
+        const to_date = `${lastDateOfMonth}-${j}-${year}`;
+        const daysOfMonth = this.getDaysOfMonth(from_date, to_date);
+        datesOfYear = [...datesOfYear, ...daysOfMonth];
+      }
+    }
+    return datesOfYear;
+  }
+
+  static getDaysOfMonth(startDay: string, endDay: string) {
+    const datesOfMonth: any = [];
+    const start_day = Number(startDay.split("-")[0]);
+    const end_day = Number(endDay.split("-")[0]);
+    const month = Number(startDay.split("-")[1]);
+    const year = Number(startDay.split("-")[2]);
+    for (let i = start_day; i <= end_day; i++) {
+      const date = `${i.toString().padStart(2, "0")}/${month
+        .toString()
+        .padStart(2, "0")}/${year}`;
+      datesOfMonth.push({
+        date: date,
+        in: "",
+        out: "",
+        status: "",
+      });
+    }
+    return datesOfMonth;
+  }
+
+  static async getAttendancefromFirestore(
+    firestore: admin.firestore.Firestore,
+    companyId: string,
+    actionId: string,
+    userId: string,
+    epochFromDate: number,
+    epochToDate: number
+  ) {
+    let userAttendancebyMonth = await firestore
+      .collection("Companies")
+      .doc(companyId)
+      .collection("Actions")
+      .doc(actionId)
+      .collection("check_in_out")
+      .where("userId", "==", userId)
+      .where("createdAt", ">=", epochFromDate)
+      .where("createdAt", "<=", epochToDate + 86400000)
+      .orderBy("createdAt", "desc")
+      .get();
+    return userAttendancebyMonth;
+  }
+
+  static async convertToTimestamp(date: any) {
+    const [day, month, year] = date.split("-");
+    const timestamp = new Date(year, month - 1, day).getTime();
+    return timestamp;
+  }
+
+  static async getformateddate(timestamp: number) {
+    let temp = new Date(timestamp).toLocaleString("en-GB", {
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+    });
+    let time = temp.split(",")[1].replace(" ", "");
+    let date = temp.split(",")[0].replace(",", "");
+    return [date, time];
+  }
+
+  static async getAttendancebyMonth(
+    firestore: admin.firestore.Firestore,
+    nickName: string,
+    phone: string,
+    month: string,
+    year: string,
+    fromDate?: string,
+    toDate?: string
+  ) {
+    let endDate = new Date(parseInt(year), parseInt(month), 0).getDate();
+    let from_date;
+    let to_date;
+    let isOnlyMonthRequired = false;
+    if (fromDate && toDate) {
+      from_date = fromDate.split("/").join("-");
+      to_date = toDate.split("/").join("-");
+    } else {
+      from_date = `01-${month}-${year}`;
+      to_date = `${endDate}-${month}-${year}`;
+      isOnlyMonthRequired = true;
+    }
+    console.log(from_date, to_date);
+    return Attendance.getAttendancebyUser(
+      firestore,
+      nickName,
+      phone,
+      from_date,
+      to_date,
+      isOnlyMonthRequired
+    );
+  }
+
+  static async getAttendanceMonthlybyTeam(
+    firestore: admin.firestore.Firestore,
+    nickName: string,
+    month: string,
+    year: string
+  ) {
+    let employeeslistbycompany: User[] = await Company.getUsersListbyCompany(
+      firestore,
+      nickName
+    );
+    if (employeeslistbycompany.length < 1) {
+      return "No employees in present company";
+    }
+    let employeesAttendance = await Promise.all(
+      employeeslistbycompany.map(async (doc) => {
+        let userMothlyAttendance = await Attendance.getAttendancebyMonth(
+          firestore,
+          nickName,
+          doc.phone,
+          month,
+          year
+        );
+        let employeeName = doc.name;
+        if (!employeeName) {
+          employeeName = "unknown";
+        }
+        return { name: employeeName, data: userMothlyAttendance.data };
+      })
+    );
+    return employeesAttendance;
+  }
+
+  static async getDailyReport(
+    firestore: admin.firestore.Firestore,
+    nickName: string,
+    phoneNo: string
+  ) {
+    let employeeslistbycompany: any[] = await Company.getTeamListOfManager(
+      firestore,
+      nickName,
+      phoneNo
+    );
+    if (employeeslistbycompany.length < 1) {
+      return null;
+    }
+    let toDate: string = await Attendance.getCurrentdate();
+    toDate = toDate.replace(/\//g, "-");
+    console.log(toDate);
+    let employeesAttendance: object[] = await Promise.all(
+      employeeslistbycompany.map(async (doc) => {
+        let employeeAttendance: any =
+          await Attendance.getByDateAttendancebyUser(
+            firestore,
+            nickName,
+            doc.phone,
+            toDate,
+            toDate
+          );
+        let employeeName = doc.name;
+        console.log(employeeAttendance);
+        if (!employeeName) {
+          employeeName = "unknown";
+        }
+        return { name: employeeName, ...employeeAttendance.data };
+      })
+    );
+    return employeesAttendance;
+  }
+
+  static async getCurrentdate() {
+    return new Date().toLocaleDateString("en-GB", { timeZone: "asia/kolkata" });
+  }
+
+  static async getCurrentTime() {
+    return new Date().toLocaleTimeString("en-GB", {
+      timeZone: "asia/kolkata",
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h12",
+    });
+  }
+
+  static async uploadEntryToReportDB(attendanceConnection: Pool, info: any) {
+    const curdService = new CurdService(attendanceConnection);
+    try {
+      const time = await Utilities.epochToMySqlDateTime(info.time);
+      const qryString = `INSERT INTO attendanceEntries (companyId, employeeName,
+                                                            eventType, timeInt, time, actionName, phoneNo, isInactive)
+                                                    VALUES ('${info.companyId}',
+                                                            '${info.employeeName}',
+                                                            '${info.eventType}',
+                                                            ${info.time},
+                                                            '${time}',
+                                                            '${info.actionName}',
+                                                            '${info.phoneNo}', false);`;
+      const result = await curdService.query(qryString);
+    } catch (error: any) {
+      console.log(error.message);
+    }
+  }
+
+  static async enrollWorkerFaceToDB(connection: Pool, data: any) {
+    const curdService = new CurdService(connection)
+    try {
+      const currentTimestamp = new Date()
+        .toISOString()
+        .replace(/T/, " ")
+        .replace(/\..+/, "");
+      const qryString = `INSERT INTO worker_enroll (
+            refId, companyId, faceJpg, name, faceTemplates, enrolledBy, dob, proofType, phone, inchargeName, proofImage, createdAt)
+            VALUES ('${data.id}', '${data.companyId}', '${data.faceJpg}',
+                '${data.name}', '${data.faceTemplates}', '${data.enrolledBy}', '${data.dob}',
+                '${data.proofType}','${data.phone}', '${data.inchargeName}', '${data.proofImage}', '${currentTimestamp}');`;
+      return await curdService.query(qryString);
+    } catch (error: any) {
+      console.log(error.message);
+      return error;
+    }
+  }
+
+  static async checkUserExist(connection: Pool, id: string) {
+    const curdService = new CurdService(connection)
+    try {
+      const qryString = `SELECT * FROM worker_enroll WHERE refId = '${id}'`;
+      return await curdService.query(qryString)
+    } catch (error: any) {
+      console.log(error.message);
+      return error;
+    }
+  }
+
+  static async updateExistUser(
+    connection: Pool,
+    data: any,
+    id: number
+  ) {
+    const curdService = new CurdService(connection)
+    try {
+      const qryString = `UPDATE worker_enroll
+            SET companyId = '${data.companyId}', faceJpg = '${data.faceJpg}', faceId = '${data.faceId}', faceName = '${data.faceName}', faceTemplates = '${data.faceTemplates}', Name = '${data.Name}', 
+            DOB = '${data.DOB}', ProofType = '${data.ProofType}', Phone = '${data.Phone}', InchargeName = '${data.InchargeName}', ProofImage = '${data.ProofImage}', created_at = CURDATE()
+            WHERE refId = '${id}';`;
+      return await curdService.query(qryString);
+    } catch (error: any) {
+      console.log(error.message);
+      return error;
+    }
+  }
+
+  static async workerCheckIn(
+    connection: Pool,
+    enrollId: number,
+    companyId: string,
+    actionName: string
+  ) {
+    const curdService = new CurdService(connection)
+    try {
+      const qryString = `INSERT INTO worker_attendance (enrollId, companyId, timeStamp, actionType)
+            VALUES ('${enrollId}', '${companyId}', NOW(), '${actionName}');`;
+      return await curdService.query(qryString);
+    } catch (error: any) {
+      console.log(error.message);
+      return error;
+    }
+  }
+
+  static async cicoValidate(
+    connection: Pool,
+    enrollId: number,
+    action: string
+  ) {
+    const curdService = new CurdService(connection)
+    try {
+      const currentDate = new Date().toISOString().split("T")[0];
+      const qryString = `SELECT * FROM worker_attendance WHERE enrollId = ${enrollId} AND actionType='${action}' AND timeStamp >= '${currentDate} 00:00:00' AND timeStamp <= '${currentDate} 23:59:59';`;
+      return await curdService.query(qryString);
+    } catch (error: any) {
+      console.log(error.message);
+      return error;
+    }
+  }
+}
+
+export { Attendance };

package/src/models/cicoPost.model.ts

@@ -0,0 +1,20 @@
+import { Post } from "./post.model";
+import * as admin from "firebase-admin";
+class CheckInCheckOutPost extends Post {
+  actionEvent: string = "";
+  actionType: string = "checkInOut";
+  actionName: string = "check_in_out";
+
+  static async sendCICOPost(firestore: admin.firestore.Firestore,
+                            cicoPost: any) {
+    await firestore.collection("Companies")
+                    .doc(cicoPost.companyId)
+                    .collection("Actions")
+                    .doc(cicoPost.actionId)
+                    .collection(cicoPost.actionName)
+                    .doc(cicoPost.eventId)
+                    .set(cicoPost)
+  }
+}
+
+export { CheckInCheckOutPost };