mobioffice-cli 0.0.1

package/src/models/contact-us/resquest.model.ts

@@ -0,0 +1,87 @@
+import * as admin from "firebase-admin";
+class Request {
+  id!: string;
+  message!: string;
+  phone!: string;
+  firstName!: string;
+  lastName!: string;
+  email!: string;
+  private _sendUpdates!: boolean;
+
+  public get sendUpdates(): boolean {
+    return this._sendUpdates;
+  }
+  public set sendUpdates(value: boolean) {
+    this._sendUpdates = value;
+  }
+
+  constructor() {}
+
+  argConstructor(
+    id: string,
+    message: string,
+    phone: string,
+    firstName: string,
+    lastName: string,
+    email: string,
+    _sendUpdates: boolean
+  ) {
+    this.id = id;
+    this.message = message;
+    this.phone = phone;
+    this.firstName = firstName;
+    this.lastName = lastName;
+    this.email = email;
+    this._sendUpdates = _sendUpdates
+  }
+
+  fromJSON(request: string) {
+    let requestJSON = JSON.parse(request);
+
+    this.id = requestJSON["phone"];
+    this.message = requestJSON["message"];
+    this.phone = requestJSON["phone"];
+    this.firstName = requestJSON["firstName"];
+    this.lastName = requestJSON["lastName"];
+    this.email = requestJSON["email"];
+    this._sendUpdates = requestJSON["sendUpdates"]
+  }
+
+  toJSON() {
+    return {
+      id: this.phone,
+      message: this.message,
+      phone: this.phone,
+      firstName: this.firstName,
+      lastName: this.lastName,
+      email: this.email,
+      sendUpdates: this._sendUpdates
+    };
+  }
+
+  async save(firestore: admin.firestore.Firestore) {
+    let requestDoc: admin.firestore.DocumentReference = firestore
+      .collection("Requests")
+      .doc(this.phone.toString());
+    
+    const requestDocInfo = await requestDoc.get();
+    const reqsInfo = requestDocInfo.data();
+    if (reqsInfo) {
+      reqsInfo.requests.push(this.toJSON());
+      await requestDoc.set(reqsInfo)
+    } else {
+      const newRequest = {
+        id: this.phone,
+        requests: [this.toJSON()]
+      }
+      await requestDoc.set(newRequest);
+    }
+    return {
+      status: "OK",
+      message: "Request Added Successfully",
+      path: requestDoc.path,
+    };
+  }
+}
+
+export { Request };

package/src/models/crud/crud.ts

@@ -0,0 +1,30 @@
+import { Pool, PoolConnection, RowDataPacket, ResultSetHeader, OkPacket } from 'mysql2';
+
+class CurdService {
+  private pool: Pool;
+
+  constructor(pool: Pool) {
+    this.pool = pool;
+  }
+
+  public async query(queryString: string): Promise<RowDataPacket[] | ResultSetHeader | OkPacket> {
+    return new Promise((resolve, reject) => {
+      this.pool.getConnection((err, connection: PoolConnection) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        connection.query(queryString, (err, result:any) => {
+          connection.release();
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve(result);
+        });
+      });
+    });
+  }
+}
+
+export default CurdService;

package/src/models/customCollection.model.ts

@@ -0,0 +1,47 @@
+import * as admin from "firebase-admin"
+import { User } from "./user.model";
+
+class CustomCollection {
+  id: string = "";
+
+  static async createCustomCollection(
+    firestore: admin.firestore.Firestore,
+    collectionDetails: any
+  ) {
+    try {
+      let collection_snapshot = await firestore.collection("customCollection")
+                                              .get();
+      if (collection_snapshot.empty) {
+        console.log("no collection found: creating one...");
+        await CustomCollection.createNewCollection(firestore, collectionDetails);
+      } else {
+        throw new Error("there is already a collection with this name.");
+      }
+    } catch (error) {
+      console.log(error);
+    }
+  }
+
+  static async createNewCollection(firestore: admin.firestore.Firestore,
+                                    collectionDetails: any) {
+    let restructuredDetails: any = await CustomCollection.restructureDetails(collectionDetails);
+    let docRef = firestore.collection("CustomCollections").doc();
+    restructuredDetails.id = docRef.id;
+    await docRef.set(restructuredDetails);
+    return restructuredDetails;
+  }
+
+  static async restructureDetails(collectionDetails: any) {
+    // for now collectionDetails remain unaltered
+    return collectionDetails;
+  }
+
+  static async getUserWorkAreaList(firestore:admin.firestore.Firestore,companyId:string,phone:string){
+    let userId = await User.getUserIdByPhone(firestore,phone)
+    let workAreaSnapShot = await firestore.collection("CustomCollections").doc(companyId).collection("Users").doc(userId).get()
+    return workAreaSnapShot.data()
+  }
+  
+}
+
+export { CustomCollection };

package/src/models/customer/customer.model.ts

@@ -0,0 +1,85 @@
+import { Firestore } from "@google-cloud/firestore";
+import * as admin from "firebase-admin";
+
+class Customer {
+  customerName: string;
+  address: string;
+  zipcode: string;
+  city: string;
+  state: string;
+  GSTNo: string;
+  contactName: string;
+  contactNo: string;
+
+  constructor(customerName: string,
+              address: string,
+              zipcode: string,
+              city: string,
+              state: string,
+              GSTNo: string,
+              contactName: string,
+              contactNo: string) {
+    this.customerName = customerName;
+    this.address = address;
+    this.zipcode = zipcode;
+    this.city = city;
+    this.state = state;
+    this.GSTNo = GSTNo;
+    this.contactName = contactName;
+    this.contactNo = contactNo;
+  }  
+}
+
+class CustomerContact {
+  customerId: number;
+  contactName: string;
+  contactNo: string;
+  alternateContactNo: string;
+  designation: string;
+  constructor(
+    customerId: number,
+    contactName: string,
+    contactNo: string,
+    alternateContactNo: string,
+    designation: string
+  ) {
+    this.customerId = customerId;
+    this.contactName = contactName;
+    this.contactNo = contactNo;
+    this.alternateContactNo = alternateContactNo;
+    this.designation = designation;
+  }
+}
+
+class CustomerCard {
+  companyId: string;
+  userId: string;
+  createdAt: string;
+  actionName: string;
+  actionType: string;
+  actionId: string;
+  actionEvent: string;
+  extraData: any;
+  id: string;
+  constructor(companyId: string,
+              userId: string,
+              createdAt: string,
+              actionName: string,
+              actionType: string,
+              actionId: string,
+              actionEvent: string,
+              extraData: any,
+              id: string) {
+    this.companyId = companyId;
+    this.userId = userId;
+    this.createdAt = createdAt;
+    this.actionName = actionName;
+    this.actionType = actionType;
+    this.actionId = actionId;
+    this.actionEvent = actionEvent;
+    this.extraData = extraData;
+    this.id = id;
+  }
+}
+
+export { Customer, CustomerContact, CustomerCard };

package/src/models/deviceChangeReq.ts

@@ -0,0 +1,150 @@
+import * as admin from "firebase-admin";
+import { Action } from "./action.model";
+import { Company } from "./company.model";
+import { Offline } from "./offline.model";
+class DeviceChangeReq {
+  static async checkIsReqPending(firestore: admin.firestore.Firestore,
+                                  deviceChangeInfo: any, company: string) {
+    const newDeviceId = deviceChangeInfo.extra.extraData.deviceId;
+    const nickName = "mobiOffice";
+    const requestCompanyId = await Company.getCompanyIdByNickName(firestore, company);
+    console.log("requestCompanyId", requestCompanyId);
+    const companyId = await Company.getCompanyIdByNickName(firestore, nickName);
+    const actionName = deviceChangeInfo.actionName;
+    let isReqPending = false;
+    console.log("companyId", companyId, "actionName", actionName);
+    const actionId = await Action.getActionId(firestore, companyId, actionName);
+    console.log(companyId, requestCompanyId);
+    const deviceChangeReqs = await firestore.collection("Companies")
+                                            .doc(companyId)
+                                            .collection("Actions")
+                                            .doc(actionId)
+                                            .collection(actionName)
+                                            .where("reqCompanyId", "==", requestCompanyId)
+                                            .get()
+    deviceChangeReqs.forEach((doc: any) => {
+      console.log("compare", doc.data().extraData.deviceId, newDeviceId, doc.data().isProcessed);
+      if (doc.data().extraData.deviceId === newDeviceId
+          && doc.data().isProcessed === false) {
+        isReqPending = true;
+      }
+    })
+    return isReqPending;
+  }
+
+  static async fetchOpenReqs(firestore: admin.firestore.Firestore,
+                              companyId: string) {
+    const nickName = "mobiOffice";
+    const supportCompanyId = await Company.getCompanyIdByNickName(firestore, nickName);
+    const actionName = "requestForm";
+    const actionId = await Action.getActionId(firestore, supportCompanyId, actionName);
+    const allRequestsDocs = await firestore.collection("Companies")
+                                        .doc(supportCompanyId)
+                                        .collection("Actions")
+                                        .doc(actionId)
+                                        .collection(actionName)
+                                        .get();
+    let allRequestsData = allRequestsDocs.docs.map((doc) => {
+      return doc.data();
+    })
+    let openRequests = allRequestsData.filter((doc) => {
+      return doc.reqCompanyId === companyId && !doc.isProcessed;
+    })
+    return openRequests;
+  }
+
+  static async approve(firestore: admin.firestore.Firestore,
+                  approvalDetails: any) {
+    const extraData = approvalDetails.extra.extraData;
+    const companyId = extraData.companyNameId;
+    const requestId = extraData.requestId;
+    const requestStatus = extraData.approval;
+    const openRequests = await this.fetchOpenReqs(firestore, companyId);
+    const objToProcess: any = [];
+    openRequests.forEach(async (doc) => {
+      if( doc.eventId === requestId) {
+        objToProcess.push(doc);
+      }
+    })
+    if (objToProcess.length !== 0) {
+      const licenseDoc = await firestore.collection("Licenses")
+                                      .where("company", "==", objToProcess[0].company)
+                                      .where("user", "==", `+${objToProcess[0].extraData.phone}`)
+                                      .get();
+      let license =  licenseDoc.docs.map((doc) => {
+        return doc.data();
+      })[0];
+      const updatedLicense = await this.replaceOldDeviceWithNew(license, objToProcess[0]);
+      console.log(updatedLicense);
+      if (updatedLicense) {
+        licenseDoc.forEach(doc => {
+          doc.ref.set(updatedLicense);
+        })
+      }
+      await this.updateCompanyActionDoc(firestore, requestId, requestStatus);
+    } else {
+      throw new Error("no documents to process");
+    }
+  }
+
+  static async replaceOldDeviceWithNew(license: any, objToProcess: any) {
+    const extraDevices = license.extraDevices;
+    const newDeviceObj = {
+      fromDate: Date.now(),
+      modelName: objToProcess.extraData.model,
+      brandName: objToProcess.extraData.brand,
+      deviceId: objToProcess.extraData.deviceId
+    }
+    const indexToReplace = await this.getIndexToReplace(extraDevices, objToProcess.extraData.oldDeviceId);
+    if (indexToReplace === "not found") {
+      return null;
+    }
+    extraDevices.splice(indexToReplace, 1, newDeviceObj);
+    license.extraDevices = extraDevices;
+    return license;
+  }
+
+  static async getIndexToReplace(extraDevices: any, deviceId: string) {
+    for (let i = 0; i < extraDevices.length; i++) {
+      if (extraDevices[i].deviceId === deviceId) {
+        return i;
+      }
+    }
+    return "not found";
+  }
+
+  static async updateCompanyActionDoc(firestore: admin.firestore.Firestore,
+                                      requestId: string,
+                                      requestStatus: string) {
+    const companyId = await Company.getCompanyIdByNickName(firestore, "mobiOffice");
+    const actionName = "requestForm";
+    const actionId = await Action.getActionId(firestore, companyId, actionName);
+    const doc = await firestore.collection("Companies")
+                                  .doc(companyId)
+                                  .collection("Actions")
+                                  .doc(actionId)
+                                  .collection(actionName)
+                                  .doc(requestId)
+                                  .get();
+    await doc.ref.update({
+      isProcessed: true,
+      approval: requestStatus
+    })
+
+    const supportUsers = await Company.getUsersListbyCompany(firestore, "mobiOffice");
+
+    for(let user of supportUsers) {
+      const docRef = await firestore.collection("Feeds").doc(user.id).collection(companyId).doc(requestId).get();
+      const docData = docRef.data();
+      const extraData = docData?.extraData;
+      extraData["approval"] = requestStatus 
+      await firestore.collection("Feeds").doc(user.id).collection(companyId).doc(requestId).update({
+        isProcessed: true,
+        extraData: extraData
+      })
+    }
+
+  }
+}
+
+export { DeviceChangeReq };

package/src/models/dispatch.model.ts

@@ -0,0 +1,99 @@
+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 Dispatch extends Post {
+  actionEvent: string = "";
+  actionType: string = "worklog";
+  actionName: string = "dispatch";
+  customerName:string = ""
+
+  static async createPostforDispatch(firestore: admin.firestore.Firestore,postInfo: any,uniqueId:string){
+    let post = new Dispatch();
+    post = await Dispatch.setIncomingInfoToDispatch(postInfo, post);
+    console.log(post)
+    let eventId = await Post.createNewPost(firestore,post)
+    await TempCollection.deleteTempCollection(firestore,uniqueId)
+    return eventId
+  }
+
+  static async createPostForSODispatch(firestore: admin.firestore.Firestore, postInfo: any, status: string) {
+    console.log("in create post for dispatch");
+    const userInfo: any = await User.getUserInfoById(firestore, postInfo.userId, postInfo.companyId);
+    const extraData = postInfo.extra.extraData;
+    extraData.status = status;
+    extraData.time = postInfo.createdAt;
+    extraData.date = new Date(postInfo.createdAt).toLocaleDateString("en-GB");
+    extraData.userName = userInfo.name;
+    console.log(extraData);
+    let post = {
+      ...postInfo,
+      extraData: extraData,
+      actionId: postInfo.extra.actionId,
+      description: postInfo.extra.extraData.customerName,
+      actionType: "worklog"
+    };
+    delete post.extra;
+    console.log(post);
+    console.log("creating post for dispatch");
+    let eventId = await Post.createNewPost(firestore, post);
+    return eventId;
+  }
+
+  static async setIncomingInfoToDispatch(info:any, post:Dispatch){
+    post.actionEvent = info.extra.actionEvent;
+    post.id = info.id
+    post.customerName = info.customerName
+    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.modifyExtraDataForDispatch(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 modifyExtraDataForDispatch(info: any) {
+    const time = info.createdAt;
+    const date = new Date(time).toLocaleDateString("en-GB");
+    const newExtraData = {
+      ...info.extra.extraData,
+      status: "Pending",
+      customerName: info.description.split("--")[0],
+      date: date,
+      time: time 
+    }
+    return newExtraData;
+  }
+
+  static async getSODesignsByDocId(firestore: admin.firestore.Firestore,
+                                    uniqueId: string) {
+    try {
+      const storedInfoDoc = await firestore.collection("TempCollection")
+                                            .doc(uniqueId)
+                                            .get();
+      const info: any = storedInfoDoc.data();
+      console.log(info.scannedTakas);
+      return info.scannedTakas;
+    } catch(error: any) {
+      throw new Error(error.message)
+    }
+  }
+}
+
+export { Dispatch };

package/src/models/feed.models.ts

@@ -0,0 +1,104 @@
+import * as admin from 'firebase-admin';
+import { Attendance } from './attendance.model';
+import { Offline } from './offline.model';
+
+class Feeds {
+
+  static async initFeed(firestore: admin.firestore.Firestore) {
+    let document = firestore.collection('Feeds').doc();
+    await document.set({
+      id: document.id,
+    })
+    return "success"
+  }
+
+  static async updateFeed(firestore: admin.firestore.Firestore, userId: string, companyId: string, eventId: string, data: any, isError: boolean, lotNo: string) {
+    console.log("going to update cards");
+    await Feeds.updateFeedForUser(firestore, userId, companyId, eventId, data, isError, lotNo);
+    let managersList = await Offline.getUserManagersList(firestore, companyId, userId);
+    for (let manager of managersList) {
+      await Feeds.updateFeedForUser(firestore, manager, companyId, eventId, data, isError, lotNo);
+    }
+    return "success"
+  }
+
+  static async updateFeedForUser(firestore: admin.firestore.Firestore, userId: string, companyId: string, eventId: string, data: any, isError: boolean, lotNo: string) {
+    console.log("received info");
+    let userFeedDoc = await firestore.collection("Feeds").doc(userId).collection(companyId).where("eventId", "==", eventId).get()
+    let description = userFeedDoc.docs[0].data().description || "";
+    let extraData = userFeedDoc.docs[0].data().extraData
+    const oldUserFeedDoc = userFeedDoc.docs[0].data();
+    delete oldUserFeedDoc.extraData;
+    console.log("deleted extraData from oldUserFeedDoc");
+    extraData = {
+      ...extraData,
+      lotNo,
+      status: data
+    }
+    let newUserFeedDoc: any = {};
+    if (isError) {
+      console.log("api sent error response");
+      newUserFeedDoc.cardColor = "#FFF44336";
+    } else {
+      console.log("api send success response");
+      if (extraData.toBePrinted) {
+        extraData.print = extraData.toBePrinted;
+        extraData.print["lot_no"] = lotNo
+        delete extraData.toBePrinted;
+      }
+    }
+
+    description = `${description}--${data.split(" ").slice(0, 3).join(" ")}`;
+
+    console.log("updated the description");
+    newUserFeedDoc = {
+      ...oldUserFeedDoc,
+      ...newUserFeedDoc,
+      description: description,
+      extraData: extraData
+    }
+    console.log("going to set the newUserFeedDoc");
+    userFeedDoc.forEach((doc) => {
+      doc.ref.set(newUserFeedDoc)
+    })
+    console.log("done");
+    // userFeedDoc.forEach((doc)=>{
+    //   doc.ref.update({
+    //     description:description,
+    //     extraData:extraData
+    //   })
+    //   if (doc.data().tobePrinted) {
+    //     doc.ref.update({
+    //       print: doc.data().tobePrinted
+    //     })
+    //   }
+    //   if (isError) {
+    //     doc.ref.update({
+    //       cardColor: "#FFF44336"
+    //     })
+    //   }
+    // })
+    return "success"
+  }
+
+  static async updateEndMeetingsTimeInFeeds(firestore: admin.firestore.Firestore, userId: string, companyId: string, eventId: string, endTime: number) {
+    let userFeedDoc = await firestore.collection("Feeds").doc(userId).collection(companyId).where("eventId", "==", eventId).get()
+    if (userFeedDoc.docs.length) {
+      let extraData = userFeedDoc.docs[0].data().extraData
+      extraData = {
+        ...extraData,
+        "End Time": endTime
+      }
+      console.log(extraData)
+      userFeedDoc.forEach((doc) => {
+        doc.ref.update({
+          extraData: extraData
+        })
+      })
+      return "success"
+    }
+  }
+
+
+}
+export { Feeds };

package/src/models/geofence.model.ts

@@ -0,0 +1,61 @@
+import * as admin from "firebase-admin";
+import { Company } from "./company.model";
+
+class Geofence{
+
+    static async getOrCreateGeoFence(firestore:admin.firestore.Firestore,geofenceDoc:any){
+        let snapshot = await firestore.collection('Geofence').where('companyNickName','==',geofenceDoc.companyNickName).get()
+        if(snapshot.empty){
+            if(!geofenceDoc.companyId){
+                let companynickname = await Company.getCompanyIdbyNickname(firestore,geofenceDoc.companyNickName)
+                geofenceDoc.companyId = companynickname
+            }
+            geofenceDoc = await Geofence.convertGeofenceDataType(geofenceDoc)
+            let geofence_snapshot = firestore.collection("Geofence").doc()
+            let docId = geofence_snapshot.id
+            geofenceDoc.id = docId
+            geofence_snapshot.set(geofenceDoc)
+            return geofenceDoc
+        }
+        return snapshot.docs[0].data()
+    }
+
+    static async convertGeofenceDataType(geoFenceDoc:any){
+        if(geoFenceDoc.geoFenceIds){
+            geoFenceDoc.geoFenceIds = geoFenceDoc.geoFenceIds.split('&').map(Number)
+        }else{
+            geoFenceDoc.geoFenceIds = []
+        }
+        for(let value of geoFenceDoc.geoFence){
+            if(value.area){
+                value.area = Number(value.area)
+            }
+            value.attributes = {}
+            if(value.calendarId){
+                value.calendarId = Number(value.calendarId)
+            }
+            if(value.id){
+                value.id = Number(value.id)
+            }
+        }
+        return geoFenceDoc
+    }
+
+    static async updateGeofence(firestore:admin.firestore.Firestore,arrayUnion:any,geofenceDoc:any){
+        let snapshot = await firestore.collection('Geofence').where('companyNickName','==',geofenceDoc.companyNickName).get()
+        if(snapshot.empty){
+            return `create geofence for this company ${geofenceDoc.nickName}`
+        }else{
+            for(let geofenceDetail of geofenceDoc.geoFence){
+                snapshot.forEach((doc)=>{
+                    doc.ref.update({
+                        geoFence: arrayUnion(geofenceDetail),
+                        geoFenceIds:arrayUnion(geofenceDetail.id)
+                    })
+                })
+            }
+            return "updated successfully"
+        }
+    }
+}
+export { Geofence }