mobioffice-cli 0.0.1

package/src/models/post.model.ts

@@ -0,0 +1,105 @@
+import { Offline } from "./offline.model";
+import * as admin from "firebase-admin";
+import { Dispatch } from "./dispatch.model";
+import { Company } from "./company.model";
+import { User } from "./user.model";
+import { Action } from "./action.model";
+class Post {
+  actionEvent: string = "";
+  actionId : string = "";
+  actionName: string = "";
+  actionType: string = "";
+  companyId: string = "";
+  createdAt: string = "";
+  refId: string = "";
+  description: string = "";
+  eventId : string = "";
+  isGeofence: boolean = false;
+  userId: string = "";
+  id: string = "";
+  forApproval: boolean = false;
+  forApprovalText: string = "";
+  object: any = null;
+  origin: any = null;
+  seen: boolean = false;
+  startAt: string = "";
+  startLat: string = "";
+  startLong: string = "";
+  endAt: string = "";
+  endLat: string = "";
+  endLong: string = "";
+  stepValues: any[] = [];
+  target: string = "";
+  time: string = "";
+  extraData: any = {};
+  checkInternet: boolean = false;
+  image: string = "";
+  eventDetails: string = "";
+  isProcessed: boolean = false;
+  missedEvent: string = "";
+
+  static async createNewPost(firestore:admin.firestore.Firestore,postInfo: any){
+    let incomingDocId = postInfo.id
+    try{
+      let userRef = await Offline.createRefForUser(firestore, postInfo.companyId, postInfo.userId);
+      postInfo.id = userRef.id;
+      const postToSave = JSON.parse(JSON.stringify(postInfo));
+      console.log("------before saving in company")
+      let postEventId = await Offline.addDetailsToCompanyActions(firestore,
+                                            postInfo.companyId,
+                                            postInfo.actionId,
+                                            postToSave,
+                                            postInfo.actionName);
+      postToSave.eventId = postEventId;
+      await userRef.set(postToSave);
+      console.log("post sent to user feed");
+      await Offline.sendFeedToManagers(firestore,
+                                    postInfo.companyId,
+                                    postInfo.userId,
+                                    postToSave);
+      console.log("post sent to managers' feed",postToSave.startAt)
+      await Offline.deleteInfoFromIncoming(firestore, incomingDocId);
+      console.log("document deleted from incoming");
+      return postEventId
+    }
+    catch(error){
+      await firestore.collection("Incoming").doc(incomingDocId).update({
+        message: "Error",
+        errorDetail: error,
+        errorId: "err101",
+      })
+      console.log(error)
+      return error
+    }         
+  }
+
+  static async sendDCRPost(firestore: admin.firestore.Firestore,
+                            postToSave: any) {
+    const nickName = "mobiOffice";
+    const companyId = await Company.getCompanyIdByNickName(firestore, nickName);
+    const actionId = await Action.getActionId(firestore, companyId, postToSave.actionName)
+    const supportUsers = await Company.getUsersListbyCompany(firestore, nickName);
+    console.log(actionId, companyId);
+    const postEventDocRef = firestore.collection("Companies")
+                                      .doc(companyId)
+                                      .collection("Actions")
+                                      .doc(actionId)
+                                      .collection(postToSave.actionName)
+                                      .doc(postToSave.id)
+    postToSave.eventId = postToSave.id;
+    await postEventDocRef.set(postToSave)
+    const feedIdObj: any = {}
+    for (let user of supportUsers) {
+      let userRef = firestore.collection("Feeds")
+                            .doc(user.id)
+                            .collection(companyId)
+                            .doc(postToSave.id)
+      // postToSave.id = userRef.id;
+      await userRef.set(postToSave);
+      // feedIdObj[user.id] = userRef.id;
+    }
+    // return feedIdObj;
+  }
+}
+
+export { Post };

package/src/models/printDetailsScreen.model.ts

@@ -0,0 +1,30 @@
+import * as admin from 'firebase-admin';
+import { Company } from './company.model';
+
+class PrintDetailsScreen {
+
+    static async createPrintDetailsScreen(firestore:admin.firestore.Firestore,nickName:string,data:any){
+        let companyId = await Company.getCompanyIdbyNickname(firestore,nickName);
+        let snapshot = firestore
+        .collection("Companies")
+        .doc(companyId)
+        .collection("Print-Details-Screen").doc()
+        data.id = snapshot.id
+        await snapshot.set(data)
+        return data
+    }
+
+
+    static async updatePrintDetailsScreen(firestore:admin.firestore.Firestore,nickName:string,data:any){
+        let companyId = await Company.getCompanyIdbyNickname(firestore,nickName);
+        let snapshot = await firestore
+        .collection("Companies")
+        .doc(companyId)
+        .collection("Print-Details-Screen").where("actionName","==",data.actionName).get()
+        snapshot.forEach((doc)=>{
+            doc.ref.update(data)
+        })
+    }
+
+}
+export { PrintDetailsScreen };

package/src/models/pushNotifications/pushNotification.model.ts

@@ -0,0 +1,17 @@
+import { firestore } from "firebase-admin";
+
+class PushNotifications {
+  static async sendPushNotification(admin: any,
+                                    fcmTokens: string[], message: any) {
+    try {
+      const response = await admin.messaging().sendToDevice(fcmTokens, message);
+      console.log(response.results);
+      // console.log(response[0].error)
+      return "Notification Sent Successfully"
+    } catch (error: any) {
+      throw new Error(error.message) 
+    }
+  }
+}
+
+export { PushNotifications };

package/src/models/report-actions.model.ts

@@ -0,0 +1,57 @@
+import * as admin from 'firebase-admin';
+import { Action } from './action.model';
+import { Company } from './company.model';
+class ReportActions {
+  darkColor: string = "";
+  lightColor: string = "";
+  description: string = "";
+  icon: string = "";
+  title: string = "";
+  url: string = "";
+  id:string = "";
+  order: string = "";
+  keys: string = "";
+
+  static async getOrCreateReportActions(firestore:admin.firestore.Firestore,nickName:string,reportAction:any){
+    if(!reportAction.title){
+      return "Please provide title"
+    }
+    let companyId = await Company.getCompanyIdbyNickname(firestore,nickName)
+    let snapshot = firestore.collection('Companies').doc(companyId).collection('Report-Actions')
+    let reportAction_data = await snapshot.where('title','==',reportAction.title).get()
+    if(reportAction_data.empty){
+      let actionId = await Action.getActionIdByDisplayName(firestore,companyId,reportAction.title);
+      //reportAction = await ReportActions.convertReportActionsDataType(reportAction)
+      reportAction.id = actionId
+      let reportaction_snapshot_newData = snapshot.doc(actionId)
+      await reportaction_snapshot_newData.set(reportAction)
+      return (await reportaction_snapshot_newData.get()).data()
+    }else{
+      return reportAction_data.docs[0].data()
+    }
+  }
+
+  static async convertReportActionsDataType(data:any){
+    if(data.keys){
+      data.keys = data.keys.split('&')
+    }
+    if(data.order){
+      data.order = Number(data.order)
+    }
+    return data
+  }
+
+  static reportActionsTemplate = {
+    darkColor: null,
+    lightColor: null,
+    description: null,
+    icon: null,
+    title: null,
+    url: null,
+    id: null,
+    order: null,
+    keys: null,
+  };
+}
+
+export { ReportActions };

package/src/models/report-definition-details.model.ts

@@ -0,0 +1,89 @@
+import * as admin from 'firebase-admin';
+import { Action } from './action.model';
+import { Company } from './company.model';
+import { ReportDefinitionSummary } from './report-definitions-summary.model';
+
+
+class ReportDefinitionDetail {
+    color:string = "";
+    data:any[] = [];
+    detailOf:string = "";
+    name:string = "";
+    toHome:boolean = false;
+    id:string = ""
+    nickname?:string = ""
+
+
+    static async getOrCreateReportDefinitionDetail(firestore:admin.firestore.Firestore,nickName:string,reportDefinitionDetail:ReportDefinitionDetail){
+        let companyId = await Company.getCompanyIdbyNickname(firestore,nickName);
+        let snapshot = firestore
+        .collection("Companies")
+        .doc(companyId)
+        .collection("Report-Definition-Detail")
+        let reportDefinitionDetials_snapshot = await snapshot.where('name','==',reportDefinitionDetail.name).get()
+        if(reportDefinitionDetials_snapshot.empty){
+            //reportDefinitionDetail = await ReportDefinitionDetail.convertReportDefinitionDetail(reportDefinitionDetail)
+            let docRef = snapshot.doc()
+            let id = await ReportDefinitionSummary.getReportDefinitionSummaryId(firestore,nickName,reportDefinitionDetail.name)
+            if(!id.length){
+                id = await Action.getActionIdByDisplayName(firestore,companyId,reportDefinitionDetail.name)
+            }
+            reportDefinitionDetail.detailOf = id
+            reportDefinitionDetail.id = docRef.id
+            await docRef.set(reportDefinitionDetail);
+            return (await docRef.get()).data()
+        }else{
+            return reportDefinitionDetials_snapshot.docs[0].data()
+        }
+    }
+
+    static async convertReportDefinitionDetail(data:any){
+        if(data.toHome){
+            data.toHome = await Action.booleanConvertion(data.toHome.toLowerCase());
+        }
+        if(data.share){
+            data.share = await Action.booleanConvertion(data.share.toLowerCase());
+        }
+        if(data.keys){
+            data.keys = await data.keys.split("&")
+        }
+        if(data.data){
+            for(let subData of data.data){
+                if(subData.autoAPICalled){
+                    subData.autoAPICalled = await Action.booleanConvertion(subData.autoAPICalled);
+                }
+                if(subData.isSSL){
+                    subData.isSSL = await Action.booleanConvertion(subData.isSSL);
+                }
+                if(subData.halfPage){
+                    subData.halfPage = await Action.booleanConvertion(subData.halfPage);
+                }
+                if(subData.fullPage){
+                    subData.fullPage = await Action.booleanConvertion(subData.fullPage);
+                }
+                if(subData.keys){
+                    subData.keys = subData.keys.split('&')
+                }
+                if(subData.nextPage){
+                    subData.nextPage = Number(subData.nextPage)
+                }
+                if(subData.pageSize){
+                    subData.pageSize = Number(subData.pageSize)
+                }
+                if(subData.rowHeight){
+                    subData.rowHeight = Number(subData.rowHeight)
+                }
+                if(subData.order){
+                    subData.order = Number(subData.order)
+                }
+                if(subData.totalItems){
+                    subData.totalItems = Number(subData.totalItems)
+                }
+            }
+        }
+
+        return data
+    }
+}
+
+export { ReportDefinitionDetail }

package/src/models/report-definition.model.ts

@@ -0,0 +1,26 @@
+class ReportDefinition {
+
+  id:string = "";
+  name:string = "";
+  detailOf: string = "";
+  toHome: boolean = true;
+  share:boolean = false;
+  keys:[] = [];
+  color:string = "";
+  downloadUrl:string = "";
+  data:[] = [];
+
+  static reportDefTemplate = {
+    id: "",
+    name: "",
+    detailOf: "",
+    toHome: true,
+    share: false,
+    keys: [],
+    color: "",
+    downloadUrl: "",
+    data: [],
+  };
+}
+
+export { ReportDefinition };

package/src/models/report-definitions-summary.model.ts

@@ -0,0 +1,59 @@
+import * as admin from 'firebase-admin';
+import { Action } from './action.model';
+import { Company } from './company.model';
+class ReportDefinitionSummary {
+    static async getOrCreateReportDefinitionSummary(firestore:admin.firestore.Firestore,nickName:string,reportSummary:any){
+        let companyId = await Company.getCompanyIdbyNickname(firestore,nickName)
+        let snapshot = await firestore
+        .collection("Companies")
+        .doc(companyId)
+        .collection("Report-Definition-Summary");
+        let ReportDefinitionSummary_data = await snapshot.where("name", "==", reportSummary.name).get();
+        if(ReportDefinitionSummary_data.empty){
+            reportSummary = await ReportDefinitionSummary.convertReportDefinitionSummary(reportSummary)
+            let docRef = snapshot.doc()
+            reportSummary.id = docRef.id
+            await docRef.set(reportSummary);
+            return (await docRef.get()).data()
+        }else{
+            return ReportDefinitionSummary_data.docs[0].data()
+        }
+    }
+
+    static async convertReportDefinitionSummary(data:any){
+        if(data.autoAPICall){
+            data.autoAPICall = await Action.booleanConvertion(data.autoAPICall.toLowerCase())
+        }
+        return data
+    }
+
+    static async getReportDefinitionSummaryId(firestore:admin.firestore.Firestore,nickName:string,reportDefinitionSummaryName:string){
+        let companyId = await Company.getCompanyIdbyNickname(firestore,nickName)
+        let docRef = await firestore
+        .collection("Companies")
+        .doc(companyId)
+        .collection("Report-Definition-Summary")
+        .where('name','==',reportDefinitionSummaryName)
+        .get()
+        let id = ""
+        docRef.forEach((doc)=>{
+            id = doc.data().id
+        })
+        return id
+    }
+
+    static async getReportDefinitionSummaryDocById(firestore:admin.firestore.Firestore,companyId:string,docId:string){
+        try{
+            let snapshot = await firestore.collection("Companies")
+                                          .doc(companyId)
+                                          .collection("Report-Definition-Summary")
+                                          .doc(docId)
+                                          .get()
+            return snapshot.data()
+        }
+        catch(error:any){
+            throw new Error(error.message)
+        }
+    }
+}
+export { ReportDefinitionSummary };

package/src/models/report-detail-data.model.ts

@@ -0,0 +1,49 @@
+class ReportDetailData {
+  id:string = "";
+  url:string ="";
+  reportType:string = "";
+  halfPage:boolean = true;
+  fullPage:boolean = false ;
+  pageSize:number = 10;
+  nextPage:number = 1;
+  totalItems:number = 30;
+  data: []= [];
+  autoAPICalled:boolean = false;
+  showPrint:boolean = false;
+  showBarcode:boolean = false;
+  isSSL :boolean = true;
+  saveInPublicStorage:boolean = true;
+  keys:[] = [];
+  order:number = 0;
+  type:string = "";
+
+  static reportDataType = {
+    TILE: "tile",
+    TABLE: "table",
+    PDF: "pdf",
+    TEXT: "text",
+  };
+
+  static reportDetailDataTemplate = {
+    id: "",
+    url: "",
+    loadingText: "",
+    reportType: "",
+    halfPage: true,
+    fullPage: false,
+    pageSize: 10,
+    nextPage: 1,
+    totalItems: 30,
+    data: [],
+    type: "tile",
+    autoAPICalled: false,
+    showPrint: false,
+    showBarcode: false,
+    isSSL: true,
+    saveInPublicStorage: true,
+    keys: [],
+    order: 0,
+  };
+}
+
+export { ReportDetailData };

package/src/models/report-visibility.model.ts

@@ -0,0 +1,44 @@
+import * as admin from 'firebase-admin';
+import { Company } from './company.model';
+
+class ReportVisibility{
+
+    static async setReportVisibility(firestore:admin.firestore.Firestore,nickName:string,reportVisibilityData:any){
+        let companyId = await Company.getCompanyIdbyNickname(firestore,nickName);
+        let docRef = firestore
+        .collection("Companies")
+        .doc(companyId)
+        .collection("Report-Visibility")
+        .doc(reportVisibilityData.id);
+        docRef.set(reportVisibilityData);
+        return docRef.id;
+    }
+
+    static async updateReportVisibility(firestore:admin.firestore.Firestore,arrayUnion:any,nickName:string,userId:string,reportVisibilityData:any){
+        let companyId = await Company.getCompanyIdbyNickname(firestore,nickName);
+        let docRef = await firestore.collection("Companies")
+                            .doc(companyId)
+                            .collection("Report-Visibility")
+                            .doc(userId).get();
+        await docRef.ref.update({
+            "report-sections": arrayUnion(reportVisibilityData)
+        })
+        return docRef.data()?.id
+    }
+
+    static async getUserReportList(firestore:admin.firestore.Firestore,companyId:string,userId:string){
+        try{
+            let userReportSnapshot = await firestore.collection("Companies")
+                                                    .doc(companyId)
+                                                    .collection("Report-Visibility")
+                                                    .doc(userId)
+                                                    .get()
+            let userReportsList = userReportSnapshot.data()
+            return userReportsList;
+        }
+        catch(error:any){
+            throw new Error(error.message)
+        }
+    }
+}
+export { ReportVisibility };

package/src/models/report.model.ts

@@ -0,0 +1,179 @@
+import { ReportDefinition } from "./report-definition.model";
+import * as admin from "firebase-admin";
+import { ReportActions } from "./report-actions.model";
+import { Action } from "./action.model";
+import { Utilities } from "./utility.model";
+import { ReportGenerator } from "./reportGenerator.model";
+import { Pool } from "mysql2";
+
+class Report {
+  static async addReport(
+    firebase: admin.firestore.Firestore,
+    companyId: string,
+    report: ReportDefinition
+  ) {
+    let reportRef = firebase
+      .collection("Companies")
+      .doc(companyId)
+      .collection("Report-Definition-Detail")
+      .doc();
+    report.id = reportRef.id;
+    try {
+      await reportRef.set({ ...report });
+      return report;
+    } catch (e) {
+      throw e;
+    }
+  }
+
+  static async addReportAction(
+    firestore: admin.firestore.Firestore,
+    companyId: string,
+    reportActionMap: ReportActions
+  ) {
+    var raRef = firestore
+      .collection("Companies")
+      .doc(companyId)
+      .collection("Report-Actions")
+      .doc(reportActionMap.id);
+    raRef.set({ ...reportActionMap });
+
+    return reportActionMap;
+  }
+
+  static async getReport(
+    firestore: admin.firestore.Firestore,
+    actionDBMap: Record<string, { connection: Pool, tableName: string }>,
+    nickName: string,
+    action: string,
+    timeStamps: any,
+    phone: string
+  ) {
+    try {
+      console.log("Inside getReport");
+      const startTime = await Utilities.epochToMySqlDateTime(timeStamps.fromDate);
+      const endTime = await Utilities.epochToMySqlDateTime(timeStamps.toDate);
+      const timeInterval = {
+        startTime,
+        endTime,
+      };
+      console.log(timeInterval);
+      const reportGenerator = new ReportGenerator();
+      const reportInfo = await reportGenerator.generateReport(
+        firestore,
+        actionDBMap,
+        nickName,
+        action,
+        timeInterval,
+        phone
+      );
+      return reportInfo;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  static async getCicoInfoForDay(
+    firestore: admin.firestore.Firestore,
+    userId: string,
+    companyId: string,
+    startTime: number
+  ) {
+    const cicoActionName = "check_in_out";
+    const cicoInfo = {
+      checkIn: "",
+      checkOut: "",
+    };
+    const cicoActionId = await Action.getActionId(
+      firestore,
+      companyId,
+      cicoActionName
+    );
+    const cicoInfo_snapshot = await firestore
+      .collection("Companies")
+      .doc(companyId)
+      .collection("Actions")
+      .doc(cicoActionId)
+      .collection(cicoActionName)
+      .where("userId", "==", userId)
+      .where("createdAt", ">=", startTime)
+      .where("createdAt", "<=", startTime + 86400000)
+      .orderBy("createdAt", "desc")
+      .get();
+    let checkInTime: number = 0;
+    let checkOutTime: number = 0;
+    cicoInfo_snapshot.forEach((doc: any) => {
+      if (doc.data().startAt) {
+        checkInTime = doc.data().startAt;
+      }
+      if (doc.data().endAt) {
+        checkOutTime = doc.data().endAt;
+      }
+    });
+    if (checkInTime === 0) {
+      cicoInfo.checkIn = "Not Found";
+    } else {
+      cicoInfo.checkIn = new Date(checkInTime).toLocaleTimeString("en-GB", {
+        timeZone: "asia/kolkata",
+      });
+    }
+    if (checkOutTime === 0) {
+      cicoInfo.checkOut = "Not Found";
+    } else {
+      cicoInfo.checkOut = new Date(checkOutTime).toLocaleTimeString("en-GB", {
+        timeZone: "asia/kolkata",
+      });
+    }
+    return cicoInfo;
+  }
+
+  static async getReportObjForUser(
+    firestore: admin.firestore.Firestore,
+    userId: any,
+    companyId: string,
+    action: string,
+    timeStamps: any
+  ) {
+    try {
+      let reportDocs: any = [];
+      const actionId = await Action.getActionId(firestore, companyId, action);
+      const userInfo_snapshot = await firestore
+        .collection("Companies")
+        .doc(companyId)
+        .collection("Actions")
+        .doc(actionId)
+        .collection(action)
+        .where("userId", "==", userId)
+        .get();
+      userInfo_snapshot.forEach((doc) => {
+        if (
+          doc.data().createdAt >= timeStamps.fromDate &&
+          doc.data().createdAt <= timeStamps.toDate
+        ) {
+          reportDocs.push(doc.data());
+        }
+      });
+      return reportDocs;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  static async getReportObjForDay(reportObjects: any, startTime: number) {
+    try {
+      const milliSecondsInADay = 24 * 60 * 60 * 1000;
+      let reportObjectsForDay = reportObjects.filter((obj: any) => {
+        if (obj.createdAt < startTime + milliSecondsInADay) {
+          return true;
+        } else {
+          return false;
+        }
+      });
+      return reportObjectsForDay;
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+
+export { Report };