mobioffice-cli 0.2.1 → 1.0.1

package/{src/models/tempCollection.model.ts → lib/models/tempCollection.model.js}

@@ -1,12 +1,12 @@
-import * as admin from "firebase-admin";
-import { HttpResponseAndErrorHandling } from "./response.model";
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TempCollection = void 0;
+const response_model_1 = require("./response.model");
 class TempCollection {
-    static async createTempCollection(firestore:admin.firestore.Firestore,uniqueId:string,data:any){
-        await firestore.collection("TempCollection").doc(uniqueId).set(data)
-        return "stock added"
+    static async createTempCollection(firestore, uniqueId, data) {
+        await firestore.collection("TempCollection").doc(uniqueId).set(data);
+        return "stock added";
     }
-
     // static async verifyTakaList(firestore:admin.firestore.Firestore,uniqueId:string,takaId:string,arrayInstance:any,scanType:string){
     //     let itemDetailsList_snapshot = await firestore.collection("TempCollection").doc(uniqueId).get()
     //     let itemDetailsdoc = JSON.parse(JSON.stringify(itemDetailsList_snapshot.data()))
@@ -96,33 +96,34 @@ class TempCollection {
     //         return new HttpResponseAndErrorHandling(400, "Not available", null, 400).getErrorResponse();
     //     }
     // }
-
-    static async verifyTakaList(firestore:admin.firestore.Firestore,uniqueId:string,takaId:string,arrayInstance:any,scanType:string){
-        let itemDetailsList_snapshot = await firestore.collection("TempCollection").doc(uniqueId).get()
-        let itemDetailsDoc = JSON.parse(JSON.stringify(itemDetailsList_snapshot.data()))
-        let keys = Object.keys(itemDetailsDoc)
-        if(keys.length) {
+    static async verifyTakaList(firestore, uniqueId, takaId, arrayInstance, scanType) {
+        let itemDetailsList_snapshot = await firestore.collection("TempCollection").doc(uniqueId).get();
+        let itemDetailsDoc = JSON.parse(JSON.stringify(itemDetailsList_snapshot.data()));
+        let keys = Object.keys(itemDetailsDoc);
+        if (keys.length) {
             const matchResult = await this.matchTakaInTakaList(takaId, itemDetailsDoc.takaList, scanType);
             const summary = JSON.parse(itemDetailsDoc.summary);
             let serialNo = summary.length;
             if (matchResult.status === "not found") {
                 let message = "Please verify the taka no. with system";
-                const isAlreadyScanned = await this.checkIfAlreadyScanned(itemDetailsDoc,takaId,scanType);
+                const isAlreadyScanned = await this.checkIfAlreadyScanned(itemDetailsDoc, takaId, scanType);
                 if (isAlreadyScanned) {
                     message = "This taka has been scanned already";
                 }
                 const verificationFailedResponse = await this.createResponseToSend(summary, serialNo, message);
                 return verificationFailedResponse;
-            } else if (matchResult.status === "duplicate found") {
+            }
+            else if (matchResult.status === "duplicate found") {
                 const message = "Duplicate taka exists, please select full scan";
                 const duplicateFoundResponse = await this.createResponseToSend(summary, serialNo, message);
                 return duplicateFoundResponse;
-            } else {
+            }
+            else {
                 const fullTakaId = matchResult.id;
                 const resObj = await this.createResponseObj(itemDetailsDoc, fullTakaId, serialNo + 1);
                 if (resObj.status) {
                     summary.unshift(resObj.info);
-                    serialNo = summary.length
+                    serialNo = summary.length;
                     const summaryToSave = JSON.stringify(summary);
                     await this.updateInfoInDB(itemDetailsList_snapshot, fullTakaId, summaryToSave, arrayInstance);
                     const isTakaAdded = await this.checkIfTakaIsAdded(firestore, fullTakaId, uniqueId);
@@ -130,73 +131,72 @@ class TempCollection {
                         const message = "Scan successfully";
                         const successResponse = await this.createResponseToSend(summary, serialNo, message);
                         return successResponse;
-                    } else {
+                    }
+                    else {
                         await this.resetReferenceDoc(arrayInstance, itemDetailsList_snapshot, fullTakaId);
                         const message = "Taka Scan failed, please scan again";
-                        const responseToSend = await this.createResponseToSend(summary, serialNo, message)
-                        return responseToSend
+                        const responseToSend = await this.createResponseToSend(summary, serialNo, message);
+                        return responseToSend;
                     }
-                } else {
+                }
+                else {
                     const message = "Please verify taka with the system";
-                    const responseToSend = await this.createResponseToSend(summary, serialNo, message)
-                    return responseToSend
+                    const responseToSend = await this.createResponseToSend(summary, serialNo, message);
+                    return responseToSend;
                 }
             }
-        } else {
-            return new HttpResponseAndErrorHandling(400, "Not available", null, 400).getErrorResponse();
+        }
+        else {
+            return new response_model_1.HttpResponseAndErrorHandling(400, "Not available", null, 400).getErrorResponse();
         }
     }
-
-    static async checkIfAlreadyScanned(itemDetailsDoc:any,takaId:string,scanType:string){
-        let alreadyScannedTakkaList = itemDetailsDoc.alreadyScannedTakaId
-        for(let compareStr of alreadyScannedTakkaList){
-            if(scanType == "partial"){
+    static async checkIfAlreadyScanned(itemDetailsDoc, takaId, scanType) {
+        let alreadyScannedTakkaList = itemDetailsDoc.alreadyScannedTakaId;
+        for (let compareStr of alreadyScannedTakkaList) {
+            if (scanType == "partial") {
                 compareStr = compareStr.split("-")[2];
             }
-            if(compareStr == takaId){
-                return true
+            if (compareStr == takaId) {
+                return true;
             }
         }
-        return false
+        return false;
     }
-
-    static async createCountRow(summary: any, serialNo: number) {
-        let totalQuantity = 0
-        for(let scannedTakka of summary){
+    static async createCountRow(summary, serialNo) {
+        let totalQuantity = 0;
+        for (let scannedTakka of summary) {
             totalQuantity += Number(Number(scannedTakka["Quantity"]).toFixed(3));
         }
-        let totalQuantityDoc:any = {}
-        totalQuantityDoc["Sr No"] = "Total"
-        totalQuantityDoc["Sales Order"] = "-"
-        totalQuantityDoc["Roll No"] = serialNo
-        totalQuantityDoc["Quantity"] = totalQuantity
-        totalQuantityDoc["Design"] = "-"
-        totalQuantityDoc["Color"] = "-"
-        totalQuantityDoc["Grade"] = "-"
+        let totalQuantityDoc = {};
+        totalQuantityDoc["Sr No"] = "Total";
+        totalQuantityDoc["Sales Order"] = "-";
+        totalQuantityDoc["Roll No"] = serialNo;
+        totalQuantityDoc["Quantity"] = totalQuantity;
+        totalQuantityDoc["Design"] = "-";
+        totalQuantityDoc["Color"] = "-";
+        totalQuantityDoc["Grade"] = "-";
         return totalQuantityDoc;
     }
-
-    static async updateInfoInDB(docFromDB: any, takaId: string, summaryToSave: string, arrayInstance: any) {
+    static async updateInfoInDB(docFromDB, takaId, summaryToSave, arrayInstance) {
         await docFromDB.ref.update({
             takaList: arrayInstance.arrayRemove(takaId),
-            alreadyScannedTakaId : arrayInstance.arrayUnion(takaId),
+            alreadyScannedTakaId: arrayInstance.arrayUnion(takaId),
             summary: summaryToSave
-        })
+        });
     }
-
-    static async checkIfTakaIsAdded(firestore: admin.firestore.Firestore, fullTakaId: string, uniqueId: string) {
+    static async checkIfTakaIsAdded(firestore, fullTakaId, uniqueId) {
         let itemDetailsList_snapshot = await firestore.collection("TempCollection").doc(uniqueId).get();
-        let itemDetailsDoc: any = itemDetailsList_snapshot.data();
+        let itemDetailsDoc = itemDetailsList_snapshot.data();
         const summary = JSON.parse(itemDetailsDoc.summary);
         const compareStr = summary[0]["Roll No"];
         if (compareStr === fullTakaId) {
-            return true; 
-        } else {
+            return true;
+        }
+        else {
             return false;
         }
     }
-
-    static async createResponseToSend(summary: any, serialNo: number, message: string) {
+    static async createResponseToSend(summary, serialNo, message) {
         if (summary.length) {
             const countRow = await this.createCountRow(summary, serialNo);
             summary.push(countRow);
@@ -204,24 +204,22 @@ class TempCollection {
         const result = {
             data: JSON.stringify(summary),
             message: message
-        }
+        };
         return result;
     }
-    
-    static async resetReferenceDoc(arrayInstance: any, docFromDB: any, fullTakaId: string) {
+    static async resetReferenceDoc(arrayInstance, docFromDB, fullTakaId) {
         await docFromDB.ref.update({
             takaList: arrayInstance.arrayUnion(fullTakaId),
             alreadyScannedTakaId: arrayInstance.arrayRemove(fullTakaId),
-        })
+        });
     }
-
-    static async matchTakaInTakaList(takaId: string, takaList: string[], scanType: string) {
+    static async matchTakaInTakaList(takaId, takaList, scanType) {
         let count = 0;
         const result = {
             status: "",
-            id : ""
-        }
-        let idToSave: string = "";
+            id: ""
+        };
+        let idToSave = "";
         for (let fullId of takaList) {
             let compareStr = fullId;
             if (scanType === "partial") {
@@ -232,58 +230,56 @@ class TempCollection {
                 count++;
             }
         }
-        if(count === 0) {
+        if (count === 0) {
             result.status = "not found";
-        } else if (count === 1) {
+        }
+        else if (count === 1) {
             result.status = "Success";
             result.id = idToSave;
-        } else {
+        }
+        else {
             result.status = "duplicate found";
         }
         return result;
     }
-
-    static async verifyTakaNUpdate(firestore: admin.firestore.Firestore, takaNo: string, uniqueId: string,
-                            arrayInstance: any, payLoadInfo: any, gradeInfoList: any) {
+    static async verifyTakaNUpdate(firestore, takaNo, uniqueId, arrayInstance, payLoadInfo, gradeInfoList) {
         takaNo = takaNo.toUpperCase();
         const infoDoc = await firestore.collection("TempCollection").doc(uniqueId).get();
-        const soDetails: any = infoDoc.data();
+        const soDetails = infoDoc.data();
         let summary = soDetails.summary;
         for (let i = 0; i < soDetails.takaList.length; i++) {
-            if(takaNo === soDetails.takaList[i]) {
+            if (takaNo === soDetails.takaList[i]) {
                 const infoToStore = {
                     taka_no: `${takaNo}@@${payLoadInfo.parcelNo}`,
                     selectedSODesign: payLoadInfo.selectedSODesign,
                     selectedSORowId: payLoadInfo.selectedSORowId
-                }
-                const newScanRow = await this.getNewScanRow(soDetails.takaDetails,
-                                                            soDetails.takaList[i],
-                                                            summary,
-                                                            gradeInfoList)
+                };
+                const newScanRow = await this.getNewScanRow(soDetails.takaDetails, soDetails.takaList[i], summary, gradeInfoList);
                 if (newScanRow) {
                     summary.unshift(newScanRow);
                 }
                 summary = JSON.parse(JSON.stringify(summary));
                 try {
                     await firestore.collection("TempCollection")
-                                .doc(uniqueId)
-                                .update({
-                                    scannedTakas: arrayInstance.arrayUnion(infoToStore),
-                                    takaList: arrayInstance.arrayRemove(takaNo),
-                                    summary: summary
-                                })
-                } catch(error) {
+                        .doc(uniqueId)
+                        .update({
+                        scannedTakas: arrayInstance.arrayUnion(infoToStore),
+                        takaList: arrayInstance.arrayRemove(takaNo),
+                        summary: summary
+                    });
+                }
+                catch (error) {
                     console.log(error);
                     return {
                         data: null,
                         message: "Something went wrong"
-                    }
+                    };
                 }
                 if (summary.length) {
                     const totalRow = await this.createTotalRow(summary);
                     summary.push(totalRow);
                 }
-                summary = JSON.stringify(summary)
+                summary = JSON.stringify(summary);
                 return {
                     data: summary,
                     message: "Scan successfully"
@@ -298,34 +294,30 @@ class TempCollection {
         return {
             data: summary,
             message: "Please verify the taka number with the system"
-        }
+        };
     }
-    
-    static async getGradeFromId(id: string, gradeInfoList: any) {
+    static async getGradeFromId(id, gradeInfoList) {
         for (let gradeInfo of gradeInfoList) {
             if (id === gradeInfo.id) {
                 return gradeInfo.label;
             }
         }
     }
-
-    static async getNewScanRow(takaDetails: any, currTaka: string,
-                                    oldSummary: any, gradeInfoList: any) {
-        for(let j = 0; j < takaDetails.length; j++) {
+    static async getNewScanRow(takaDetails, currTaka, oldSummary, gradeInfoList) {
+        for (let j = 0; j < takaDetails.length; j++) {
             let obj = takaDetails[j];
             if (obj.taka_no === currTaka) {
-               return {
+                return {
                     serialNo: oldSummary.length + 1,
                     ...obj,
                     grade: await this.getGradeFromId(obj.grade, gradeInfoList),
-               };
+                };
             }
         }
         return null;
     }
-
-    static async createTotalRow(summary: any) {
-        const totalRow: any = {};
+    static async createTotalRow(summary) {
+        const totalRow = {};
         let totalMeter = 0;
         for (let row of summary) {
             totalMeter += Number(Number(row.meter).toFixed(3));
@@ -336,9 +328,8 @@ class TempCollection {
         totalRow.grade = "-";
         return totalRow;
     }
-
-    static async createResponseObj(responseInfo: any,takaId:string,serialNo:string) {
-        let resObj: any = {
+    static async createResponseObj(responseInfo, takaId, serialNo) {
+        let resObj = {
             status: false,
             info: {}
         };
@@ -347,10 +338,11 @@ class TempCollection {
                 if (takaId === takaDetailsObj.taka_no) {
                     if (itemDetails.P2 === takaDetailsObj.grade) {
                         resObj.status = true;
-                    } else {
+                    }
+                    else {
                         return resObj;
                     }
-                    resObj.info["Sr No"] = serialNo
+                    resObj.info["Sr No"] = serialNo;
                     resObj.info["Sales Order"] = itemDetails.SOBookNameWithSrNo;
                     resObj.info["Roll No"] = takaId;
                     resObj.info["Quantity"] = Number(Number(takaDetailsObj.meter).toFixed(3));
@@ -360,39 +352,31 @@ class TempCollection {
                 }
             }
         }
-        return resObj
+        return resObj;
     }
-
-    static async getStockListbyUserId(firestore:admin.firestore.Firestore,userId:string){
-        let stockListSnapshot = await firestore.collection("TempCollection").doc(userId).get()
-        return stockListSnapshot.data()
+    static async getStockListbyUserId(firestore, userId) {
+        let stockListSnapshot = await firestore.collection("TempCollection").doc(userId).get();
+        return stockListSnapshot.data();
     }
-
-    static async createTempCollectionOnlyWithSerialNo(firestore:admin.firestore.Firestore,uniqueId:string,doc:any){
-        await firestore.collection("TempCollection").doc(uniqueId).set(doc)
-        return "Success"
+    static async createTempCollectionOnlyWithSerialNo(firestore, uniqueId, doc) {
+        await firestore.collection("TempCollection").doc(uniqueId).set(doc);
+        return "Success";
     }
-
-    static async deleteTempCollection(firestore:admin.firestore.Firestore,uniqueId:string){
-        await firestore.collection("TempCollection").doc(uniqueId).delete()
-        return "Deleted"
+    static async deleteTempCollection(firestore, uniqueId) {
+        await firestore.collection("TempCollection").doc(uniqueId).delete();
+        return "Deleted";
     }
-
-    static async isDocPresent(firestore:admin.firestore.Firestore,uniqueId:string){
-        let docSnapshot = await firestore.collection("TempCollection").doc(uniqueId).get()
-        return docSnapshot.exists
+    static async isDocPresent(firestore, uniqueId) {
+        let docSnapshot = await firestore.collection("TempCollection").doc(uniqueId).get();
+        return docSnapshot.exists;
     }
-
-    static async getDocInfo(firestore: admin.firestore.Firestore, uniqueId: string) {
+    static async getDocInfo(firestore, uniqueId) {
         let docSnap = await firestore.collection("TempCollection").doc(uniqueId).get();
         return docSnap.data();
     }
-
-    static async storeResponseInTemp(firestore:admin.firestore.Firestore,data:any){
-        await firestore.collection("TempCollection").doc(data.uniqueId).set(data)
-        return "Success"
+    static async storeResponseInTemp(firestore, data) {
+        await firestore.collection("TempCollection").doc(data.uniqueId).set(data);
+        return "Success";
     }
-
 }
-
-export { TempCollection }
+exports.TempCollection = TempCollection;

package/lib/models/user.model.d.ts

@@ -0,0 +1,42 @@
+import * as admin from "firebase-admin";
+declare class User {
+    reportingTo: string | null;
+    managers: string[];
+    bio: string | null;
+    fcmToken: string | null;
+    email: string | null;
+    avatarUrl: string | null;
+    satOff: string | null;
+    id: string;
+    designation: string | null;
+    roles: string;
+    roamId: string | null;
+    birthDate: number;
+    name: string;
+    hasCheckedIn: boolean;
+    department: string | null;
+    empCode: string | null;
+    phone: string;
+    constructor(reportingTo: any, managers: string[], bio: string, fcmToken: string, email: string, avatarUrl: string, satOff: string, id: string, designation: string, roles: string, roamId: string, birthdate: number, name: string, hasCheckedIn: boolean, department: string, empCode: string, phone: string);
+    static initUsers(firestore: admin.firestore.Firestore): Promise<string>;
+    static getUsersListByManger(firestore: admin.firestore.Firestore, nickName: string): Promise<Map<any, any>>;
+    static getUserPhonebyUserId(firestore: admin.firestore.Firestore, userId: string): Promise<any>;
+    static getUserIdByPhone(firestore: admin.firestore.Firestore, phone: string): Promise<string>;
+    static getUserInfoById(firestore: admin.firestore.Firestore, userId: string, companyId: string): Promise<admin.firestore.DocumentData | undefined>;
+    static getUsersListByCompanyNickName(firestore: admin.firestore.Firestore, nickName: string): Promise<any[]>;
+    static deleteUser(firebase: admin.firestore.Firestore, auth: any, arrayRemove: any, nickName: string, phone: string): Promise<string>;
+    static getApps(firestore: admin.firestore.Firestore, phone: string, nickName: string): Promise<{
+        id: any;
+        name: any;
+        displayName: any;
+        icon: any;
+    }[]>;
+    static getActionsByUserApp(firestore: admin.firestore.Firestore, phone: string, nickName: string, actionId: string): Promise<{
+        name: any;
+        displayName: any;
+        icon: any;
+        id: any;
+    }[]>;
+    static getHostsPhoneList(firestore: admin.firestore.Firestore, companyId: string): Promise<any[]>;
+}
+export { User };