mobioffice-cli 0.0.1

package/src/models/leaveApplicationPost.model.ts

@@ -0,0 +1,79 @@
+import { Post } from "./post.model"
+import * as admin from "firebase-admin";
+import { Action } from "./action.model";
+import { User } from "./user.model";
+import { Company } from "./company.model";
+import { Attendance } from "./attendance.model";
+import { Utilities } from "./utility.model";
+
+class LeaveApplication extends Post {
+  actionEvent: string = "";
+  actionType: string = "worklog";
+  actionName: string = "leave-application";
+  isProcessed: boolean = false;
+
+  static async setIncomingInfoToLeaveApplicationPost(info: any, post: LeaveApplication) {
+    post.actionEvent = info.extra.actionEvent;
+    post.actionId = info.extra.actionId;
+    post.actionName = info.extra.actionName;
+    post.actionType = info.extra.actionType;
+    post.companyId = info.extra.companyId;
+    post.createdAt = info.extra.createdAt;
+    post.description = `Leave application for ${info.extra.extraData.reason} on ${info.extra.extraData.leaveDate}.`;
+    post.eventId = info.extra.eventId;
+    post.isGeofence = info.extra.isGeofence;
+    post.userId = info.userId;
+    const newExtraData = await this.modifyExtraDataForLeave(info);
+    post.extraData = newExtraData;
+    post.isProcessed = false;
+    post.target = info.target || "" ;
+    post.time = info.extra.time;
+    post.checkInternet = info.extra.checkInternet;
+    return post;
+  }
+
+  static async modifyExtraDataForLeave(info: any) {
+    const time = info.extra.startAt;
+    const date = new Date(info.extra.startAt).toLocaleDateString("en-GB");
+    const newExtraData = {
+      ...info.extra.extraData,
+      date: date,
+      time: time,
+      reason: info.extra.extraData.reason,
+      appliedDate: info.extra.extraData.leaveDate,
+      forApprovalText : "Approval Pending"
+    }
+    return newExtraData;
+  }
+
+  static async getOpenedLeaveRequests(firestore: admin.firestore.Firestore,nickName: string,phone: string,actionName:string) {
+    try{
+      let teamList = await Company.getTeamListOfManager(firestore, nickName, phone);
+      teamList = teamList.map(user => user.id);
+      const allOpenRequests = [];
+      const companyId = await Company.getCompanyIdByNickName(firestore, nickName);
+      const actionId = await Action.getActionId(firestore, companyId, actionName);
+      for (let userId of teamList) {
+        const openRequestsDocs = await firestore.collection("Companies")
+                                                .doc(companyId)
+                                                .collection("Actions")
+                                                .doc(actionId)
+                                                .collection(actionName)
+                                                .where("isProcessed", "==", false)
+                                                .where("userId", "==", userId)
+                                                .get();
+        const openRequests = openRequestsDocs.docs.map(doc => {
+          return doc.data();
+        })
+        allOpenRequests.push(...openRequests);
+      }
+      return allOpenRequests;
+    }
+    catch(error:any){
+      throw new Error(error.message)
+    }
+  }
+
+}
+
+export { LeaveApplication };

package/src/models/license.model.ts

@@ -0,0 +1,215 @@
+import * as admin from 'firebase-admin';
+import { Action } from './action.model';
+import { Company } from './company.model';
+import { User } from './user.model';
+
+class License {
+  company: string = "";
+  to_date?: string = "";//new Date();
+  from_date?: string = "";//new Date();
+  user: string = "";
+  license_type?: string = "";
+  device_id: string = "";
+  static minimumDevices: number = 1;
+
+  static async validateUserLicense(firestore: admin.firestore.Firestore,
+    arrayUnion: any,
+    today_date: admin.firestore.Timestamp,
+    nickName: string,
+    user: string,
+    device_id: string,
+    modelName: string,
+    brand: string) {
+    user = user.replace(' ', '+')
+    console.log(user)
+    let userDetails_snapshot = await firestore.collection('Licenses').where('company', '==', nickName).where('user', '==', user).get();
+    if (userDetails_snapshot.empty) {
+      return ["User not found", null, null]
+    }
+    let flag: boolean = false
+    let device_flag: boolean = false
+    let license_date = await Promise.all(userDetails_snapshot.docs.map(async (doc) => {
+      if (doc.data().device_id == 1) {
+        doc.ref.update({
+          device_id: device_id,
+          extraDevices: arrayUnion({
+            deviceId: device_id,
+            modelName: modelName,
+            brandName: brand,
+            fromData: Date.now()
+          })
+        })
+        device_flag = true
+        if ((today_date.seconds * 1000) <= doc.data().to_date) {
+          flag = true
+        }
+      } else {
+        let extraDevices = doc.data().extraDevices ? doc.data().extraDevices : [];
+        extraDevices = extraDevices.map((device: any) => {
+          return device.deviceId;
+        })
+        const uniqueExtraDevices = Array.from(new Set([...extraDevices]));
+        for (let storedDeviceId of uniqueExtraDevices) {
+          if (device_id == storedDeviceId) {
+            device_flag = true
+          }
+        }
+        if ((today_date.seconds * 1000) <= doc.data().to_date) {
+          flag = true
+        }
+        if (!device_flag) {
+          let userInfo = await Company.getUserDetailsByPhone(firestore, nickName, user);
+          userInfo = userInfo[0];
+          const devicesLimit = userInfo.devicesLimit ? userInfo.devicesLimit : this.minimumDevices;
+          console.log("devicesLimit", devicesLimit);
+          if (flag) {
+            if (extraDevices.length < Number(devicesLimit)) {
+              const objToStore = {
+                deviceId: device_id,
+                modelName: modelName,
+                brandName: brand,
+                fromDate: Date.now()
+              }
+              userDetails_snapshot.forEach((doc) => {
+                doc.ref.update({
+                  extraDevices: arrayUnion(objToStore)
+                })
+              })
+              device_flag = true;
+            }
+          }
+        }
+      }
+      return doc.data().to_date
+    }))
+    let filtered_newest_date: any = license_date.reduce((a, b) => { return a > b ? a : b })
+    let convert_to_timestamp = await License.convertTimestamptoDate(filtered_newest_date)
+    const status = flag && device_flag;
+    const action = "requestForm";
+    const companyId = await Company.getCompanyIdByNickName(firestore, nickName);
+    const actionId = await Action.getActionId(firestore, companyId, action);
+    return [status, convert_to_timestamp, device_flag, actionId]
+  }
+
+  static async getUserDevices(firestore: admin.firestore.Firestore, nickName: string, phone: string) {
+    let license: any = await firestore.collection("Licenses")
+      .where("user", "==", `+${phone}`)
+      .where("company", "==", nickName)
+      .get();
+    license = license.docs[0].data();
+    const devicesList = license.extraDevices.map((obj: any) => {
+      let label;
+      if (obj.modelName && obj.brandName) {
+        label = `${obj.brandName}(${obj.modelName})`;
+      }
+      return {
+        id: obj.deviceId,
+        label: label ? label : obj.deviceId
+      }
+    });
+    if (devicesList.length > 0) {
+      return {
+        data: {
+          resArray: devicesList,
+        },
+        message: "success"
+      };
+    } else {
+      return {
+        data: {
+          resArray: [{
+            label: "No devices found"
+          }]
+        },
+        message: "Error"
+      }
+    }
+  }
+
+  static async grantUserLicense(firestore: admin.firestore.Firestore, nickName: string, newUserDetails: License) {
+
+    console.log(newUserDetails)
+
+    newUserDetails.user = "+" + newUserDetails.user
+    let to_date = await License.convertDatetoTimestamp(newUserDetails["to_date"])
+    let from_date = await License.convertDatetoTimestamp(newUserDetails["from_date"])
+
+    console.log(to_date, from_date)
+
+    Object.assign(newUserDetails, { company: nickName }, { to_date: to_date }, { from_date: from_date })
+    let company_id = await Company.getCompanyIdbyNickname(firestore, newUserDetails.company)
+    if (company_id == 'Not found') {
+      return "Company does not exists"
+    }
+    let snapshot = await firestore.collection('Companies').doc(company_id).collection('Users').where('phone', '==', newUserDetails.user).get()
+    if (snapshot.empty) {
+      return "User does not exists"
+    }
+    let user_license = await firestore.collection('Licenses').where('company', '==', `${newUserDetails.company}`).where('user', '==', newUserDetails.user).get();
+
+    let flag: boolean = false
+    let user_list: any = []
+    user_license.forEach((doc) => {
+      user_list.push(doc.data())
+      if (newUserDetails.company == doc.data().company) {
+        if (newUserDetails.user == doc.data().user) {
+          if (newUserDetails.license_type == doc.data().license_type) {
+            if (newUserDetails.to_date == doc.data().to_date) {
+              flag = true
+            }
+          }
+        }
+      }
+    })
+    if (flag) {
+      return `${newUserDetails.user} data already exists`
+    }
+    await firestore.collection('Licenses').add(newUserDetails)
+    return `${newUserDetails.user} created successfully`
+  }
+  static async convertDatetoTimestamp(data: any) {
+    const [day, month, year] = data.split('-');
+    const timestamp = new Date(year, month - 1, day, 24, 0, 0).getTime();
+    return timestamp
+  }
+
+  static async convertTimestamptoDate(timestamp: number) {
+    let date = new Date(timestamp).toLocaleString()
+    return date
+  }
+
+  static async extendLicense(firestore: admin.firestore.Firestore, nickName: string, userDetails: License) {
+    userDetails.user = "+" + userDetails.user
+    let companyId = await Company.getCompanyIdbyNickname(firestore, nickName)
+    let userExist = await firestore.collection('Companies').doc(companyId).collection('Users').where('phone', '==', userDetails.user).get()
+    if (userExist.empty) {
+      return "User does exists"
+    }
+    let snapshot = await firestore.collection('Licenses').where('company', '==', nickName).where('user', '==', userDetails.user).where('license_type', '==', userDetails.license_type).get()
+    if (snapshot.empty) {
+      return "User details not found"
+    }
+    let toDateTimestamp = await this.convertDatetoTimestamp(userDetails.to_date)
+    snapshot.forEach((doc) => {
+      doc.ref.update({ to_date: toDateTimestamp })
+    })
+    return 'Updated successfully'
+  }
+
+  static async resetDeviceIdforUserLicense(firestore: admin.firestore.Firestore, company: string, phone: string) {
+    if (phone[0] != "+") {
+      phone = "+" + phone
+    }
+    console.log(phone)
+    let userLicense = await firestore.collection("Licenses").where("user", "==", phone).where("company", "==", company).get()
+    if (userLicense.empty) {
+      return { message: "User not found" }
+    }
+    userLicense.forEach((doc) => {
+      doc.ref.update({ device_id: 1 })
+    })
+    return { message: "updated" }
+  }
+}
+
+export { License };

package/src/models/log.model.ts

@@ -0,0 +1,25 @@
+import * as admin from 'firebase-admin';
+
+class Logs {
+
+    static async logEduceResponseToDB(firestore: admin.firestore.Firestore, userId: string, companyId: string, responseFromAPI: any, apiName: string) {
+        const logToStore = await this.createLogDocToStore(responseFromAPI);
+        let responseObj = {
+            createdAt: new Date().getTime(),
+            logToStore,
+            apiName
+        }
+        await firestore.collection("Logs").doc(userId).collection(companyId).doc().set(responseObj)
+    }
+
+    static async createLogDocToStore(responseFromEduce: any) {
+        let logToStore: any = {};
+        if (responseFromEduce.data) {
+            logToStore.message = responseFromEduce.message;
+        } else if (responseFromEduce.error) {
+            logToStore.error = responseFromEduce.error;
+        }
+        return logToStore;
+    }
+}
+export { Logs }

package/src/models/meeting.model.ts

@@ -0,0 +1,80 @@
+import { Pool } from "mysql2/typings/mysql/lib/Pool";
+import CurdService from "./crud/crud";
+
+class MeetingSummary {
+  customerName: string;
+  contactName: string;
+  meetingImage: string;
+  constructor(customerName: string,
+    contactName: string,
+    meetingImage: string) {
+    this.customerName = customerName;
+    this.meetingImage = meetingImage;
+    this.contactName = contactName;
+  }
+
+  static async syncReportDBFirebaseUserEntries(meetingsDBConnection:Pool,doc:any,employeeName:string) {
+    try {
+      const reportData = {
+        companyId: doc.companyId ?? "",
+        employeeName: employeeName ?? "",
+        eventId: doc.eventId ?? "",
+        userId: doc.userId ?? "",
+        phone: doc.phone ?? "",
+        meetingDate: doc.extraData.date ?? "",
+        meetingStartTime: doc.extraData["Start Time"] ?? "",
+        meetingEndTime: doc.extraData["End Time"] ?? "",
+        meetingImage: doc.extraData["meetingImage"] ?? "",
+        contactName: doc.extraData.contactName ?? "",
+        customerName: doc.extraData.customerName ?? "",
+        companyNickName: "benara",
+        time: doc.date
+      }
+      await this.uploadEntryToReportDB(meetingsDBConnection, reportData);
+    } catch (error: any) {
+      console.log(error.message);
+    }
+  }
+
+  static async uploadEntryToReportDB(meetingsConnection: Pool, info: any) {
+    const curdService = new CurdService(meetingsConnection);
+    try {
+      const qryString = `INSERT INTO meeting_reports
+                                (userId, eventId, companyId, name, phone, companyNickName,
+                                  meetingDate, meetingStartTime, meetingEndTime, contactName, customerName,
+                                  meetingImage, createOn )
+                                                VALUES ('${info.userId}',
+                                                        '${info.eventId}',
+                                                        '${info.companyId}',
+                                                        '${info.employeeName}',
+                                                        '${info.phone}',
+                                                        '${info.companyNickName}',
+                                                        '${info.meetingDate}',
+                                                        '${info.meetingStartTime}',
+                                                        '${info.meetingEndTime}',
+                                                        '${info.contactName}',
+                                                        '${info.customerName}',
+                                                        '${info.meetingImage}',
+                                                        '${info.time}')`
+      await curdService.query(qryString)
+    } catch(error: any) {
+        console.log(error.message);
+    }
+  }
+
+  static async updateEndTimeToReportDB(meetingsConnection: Pool, eventId: string, meetingEndTime:any){
+    const curdService = new CurdService(meetingsConnection)
+    try{
+      const qryString = `update meeting_reports
+                          set meetingEndTime = '${meetingEndTime}'
+                        where eventId = '${eventId}'`
+      await curdService.query(qryString)
+    }
+    catch (error) {
+      console.log(error)
+    }
+  }
+
+}
+
+export { MeetingSummary };

package/src/models/meter.model.ts

@@ -0,0 +1,62 @@
+import { Post } from "./post.model"
+import * as admin from "firebase-admin";
+import { Offline } from "./offline.model";
+import { TempCollection } from "./tempCollection.model";
+import { User } from "./user.model";
+
+class Meter extends Post {
+  actionEvent: string = "";
+  actionType: string = "worklog";
+  actionName: string = "meter_reading";
+
+  static async createPostForMeter(firestore: admin.firestore.Firestore,postInfo: any){
+    let post = new Meter();
+    post = await Meter.setIncomingInfoToMeter(postInfo, post);
+    let eventId = await Post.createNewPost(firestore,post)
+    return eventId
+  }
+
+
+  static async setIncomingInfoToMeter(info:any, post:Meter){
+    post.actionEvent = info.extra.actionEvent;
+    post.id = info.id
+    post.actionId = info.extra.actionId;
+    post.companyId = info.extra.companyId;
+    post.createdAt = info.extra.createdAt;
+    post.description = info.description;
+    post.eventId = info.extra.eventId;
+    post.isGeofence = info.extra.isGeofence;
+    post.userId = info.userId;
+    const newExtraData = await this.modifyExtraDataForMeter(info);
+    post.extraData = newExtraData;
+    post.seen = info.extra.seen;
+    post.startAt = "";
+    post.startLat = info.extra.startLat;
+    post.startLong = info.extra.startLong;
+    post.endAt = "";
+    post.endLat = info.extra.endLat;
+    post.endLong = info.extra.endLong;
+    post.stepValues = info.extra.stepValues;
+    post.time = info.extra.time;
+    post.checkInternet = info.extra.checkInternet;
+    return post;
+  }
+
+  static async modifyExtraDataForMeter(info: any) {
+    const time = info.createdAt;
+    const date = new Date(time).toLocaleDateString("en-GB");
+    const newExtraData = {
+    //   ...info.extra.extraData,
+      status: info.status,
+      machineMeterId:info.machineMeterId,
+      currentReading:info.currentReading,
+      consumption:info.consumption,
+      date: date,
+      time: time 
+    }
+    return newExtraData;
+  }
+
+}
+
+export { Meter };

package/src/models/missingPunchPost.model.ts

@@ -0,0 +1,84 @@
+import { Post } from "./post.model"
+import * as admin from "firebase-admin";
+import { Action } from "./action.model";
+import { User } from "./user.model";
+import { Company } from "./company.model";
+import { Attendance } from "./attendance.model";
+
+class MissingPunch extends Post {
+  actionEvent: string = "";
+  actionType: string = "worklog";
+  actionName: string = "mp";
+  description: string = "";
+  isProcessed: boolean = false;
+  missedEvent: string = "";
+
+  static async getOpenedMpRequests(firestore: admin.firestore.Firestore,
+                                    nickName: string,
+                                    phone: string) {
+    let teamList = await Company.getTeamListOfManager(firestore, nickName, phone);
+    teamList = teamList.map(user => user.id);
+    const allOpenRequests = [];
+    const companyId = await Company.getCompanyIdByNickName(firestore, nickName);
+    const actionId = await Action.getActionId(firestore, companyId, "mp");
+    for (let userId of teamList) {
+      const openRequestsDocs = await firestore.collection("Companies")
+                                      .doc(companyId)
+                                      .collection("Actions")
+                                      .doc(actionId)
+                                      .collection("mp")
+                                      .where("isProcessed", "==", false)
+                                      .where("userId", "==", userId)
+                                      .get();
+      const openRequests = openRequestsDocs.docs.map(doc => {
+        return doc.data();
+      })
+      allOpenRequests.push(...openRequests);
+    }
+    return allOpenRequests;
+  }
+
+  static async createUpdatedFeed(requestDoc: any,
+                                  description: string,
+                                  forApprovalText: string) {
+    const extraData = {
+      ...requestDoc.extraData,
+      forApprovalText
+    }
+    const updatedFeed = {
+      ...requestDoc,
+      description: description,
+      forApprovalText,
+      extraData
+    }
+    return updatedFeed;
+  }
+
+  static async updateFeedByUserId(firestore: admin.firestore.Firestore,
+                              updatedFeed: any,
+                              userId: string,
+                              companyId: string) {
+    const oldFeeds = await firestore.collection("Feeds")
+                                    .doc(userId)
+                                    .collection(companyId)
+                                    .where("eventId", "==", updatedFeed.eventId)
+                                    .get();
+    oldFeeds.forEach((doc) => {
+      doc.ref.set(updatedFeed);
+    })
+  }
+
+  static async updateUserManagersFeed(firestore: admin.firestore.Firestore,
+                                      updatedFeed: any,
+                                      userId: string,
+                                      companyId: string) {
+    updatedFeed.description = updatedFeed.description.slice(5);
+    const userDetails: any = await User.getUserInfoById(firestore, userId, companyId);
+    const managersList = userDetails.reportingTo;
+    for (let id of managersList) {
+      await this.updateFeedByUserId(firestore, updatedFeed, id, companyId);
+    }
+  }
+}
+
+export { MissingPunch };