mobioffice-cli 0.0.1

package/src/models/tempCollection.model.ts

@@ -0,0 +1,398 @@
+import * as admin from "firebase-admin";
+import { HttpResponseAndErrorHandling } from "./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 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){
+    //         let message = ""
+    //         let summary
+    //         if(itemDetailsdoc.summary.length < 1){
+    //             summary = []
+    //         }else{
+    //             summary = JSON.parse(itemDetailsdoc.summary);
+    //         }
+    //         let serialNo = summary.length
+    //         let isDuplicateTaka = false
+    //         let takkaMatchedflag = false
+    //         let partialId 
+    //         if(scanType.toLowerCase() == "partial"){
+    //             let i=0
+    //             for(let fulltakaId of itemDetailsdoc.takaList){
+    //                 let partialTakaId = fulltakaId.split("-")[2]
+    //                 if(takkaMatchedflag && partialTakaId == partialId){
+    //                     isDuplicateTaka = true
+    //                     break
+    //                 }
+    //                 if(partialTakaId == takaId){
+    //                     takaId = fulltakaId
+    //                     partialId = partialTakaId
+    //                     takkaMatchedflag = true
+    //                 }
+    //             }
+    //         }else{
+    //             partialId = takaId.split("-")[2]
+    //         }
+    //         if(isDuplicateTaka){
+    //             message = "Duplicate taka exists, please select full scan"
+    //         }
+    //         else if(itemDetailsdoc.alreadyScannedTakaId.includes(takaId) || itemDetailsdoc.partialScannedTakaId.includes(partialId)){
+    //             message = "This taka has been scanned already"
+    //         }
+    //         else if(itemDetailsdoc.takaList.includes(takaId)) {
+    //             serialNo += 1                 
+    //             let scannedTakkaDetails = await this.createResponseObj(itemDetailsdoc,takaId,serialNo)
+    //             summary.unshift(scannedTakkaDetails)
+    //             let summaryStringified = JSON.stringify(summary)
+    //             await itemDetailsList_snapshot.ref.update({
+    //                 summary: summaryStringified,
+    //                 takaList: arrayInstance.arrayRemove(takaId),
+    //                 alreadyScannedTakaId : arrayInstance.arrayUnion(takaId),
+    //                 partialScannedTakaId : arrayInstance.arrayUnion(partialId),
+    //             })
+    //             message = "Scan successfully"
+    //             let verifyScanTakas = await TempCollection.getTakadetails(firestore,uniqueId)
+    //             let scannedSummary = JSON.parse(verifyScanTakas.summary)
+    //             if(scannedSummary[0]["Roll No"] != takaId){
+    //                 await itemDetailsList_snapshot.ref.update({
+    //                     takaList: arrayInstance.arrayUnion(takaId),
+    //                     alreadyScannedTakaId : arrayInstance.arrayRemove(takaId),
+    //                     partialScannedTakaId : arrayInstance.arrayRemove(partialId),
+    //                 })
+    //                 message = "Scan Failed, Please rescan the taka"
+    //             }
+    //             console.log(message)
+    //         }
+    //         else{
+    //             message = "Please verify the taka number with the system"
+    //         }
+    //         if(summary.length){
+    //             let totalQuantity = 0
+    //             for(let scannedTakka of summary){
+    //                 totalQuantity += parseInt(scannedTakka["Quantity"])
+    //             }
+    //             let totalQuantityDoc:any = {}
+    //             totalQuantityDoc["Sr No"] = "Total"
+    //             totalQuantityDoc["Sales Order"] = "-"
+    //             totalQuantityDoc["Roll No"] = serialNo
+    //             totalQuantityDoc["Quantity"] = totalQuantity
+    //             totalQuantityDoc["Design"] = "-"
+    //             totalQuantityDoc["Color"] = "-"
+    //             totalQuantityDoc["Grade"] = "-"
+    //             summary.push(totalQuantityDoc)
+    //         }
+    //         return {
+    //             data: JSON.stringify(summary),
+    //             message: message
+    //         }
+    //     }else{
+    //         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) {
+            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);
+                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") {
+                const message = "Duplicate taka exists, please select full scan";
+                const duplicateFoundResponse = await this.createResponseToSend(summary, serialNo, message);
+                return duplicateFoundResponse;
+            } else {
+                const fullTakaId = matchResult.id;
+                const resObj = await this.createResponseObj(itemDetailsDoc, fullTakaId, serialNo + 1);
+                if (resObj.status) {
+                    summary.unshift(resObj.info);
+                    serialNo = summary.length
+                    const summaryToSave = JSON.stringify(summary);
+                    await this.updateInfoInDB(itemDetailsList_snapshot, fullTakaId, summaryToSave, arrayInstance);
+                    const isTakaAdded = await this.checkIfTakaIsAdded(firestore, fullTakaId, uniqueId);
+                    if (isTakaAdded) {
+                        const message = "Scan successfully";
+                        const successResponse = await this.createResponseToSend(summary, serialNo, message);
+                        return successResponse;
+                    } 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
+                    }
+                } else {
+                    const message = "Please verify taka with the system";
+                    const responseToSend = await this.createResponseToSend(summary, serialNo, message)
+                    return responseToSend
+                }
+            }
+        } else {
+            return new 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"){
+                compareStr = compareStr.split("-")[2];
+            }
+            if(compareStr == takaId){
+                return true
+            }
+        }
+        return false
+    }
+
+    static async createCountRow(summary: any, serialNo: number) {
+        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"] = "-"
+        return totalQuantityDoc;
+    }
+
+    static async updateInfoInDB(docFromDB: any, takaId: string, summaryToSave: string, arrayInstance: any) {
+        await docFromDB.ref.update({
+            takaList: arrayInstance.arrayRemove(takaId),
+            alreadyScannedTakaId : arrayInstance.arrayUnion(takaId),
+            summary: summaryToSave
+        })
+    }
+
+    static async checkIfTakaIsAdded(firestore: admin.firestore.Firestore, fullTakaId: string, uniqueId: string) {
+        let itemDetailsList_snapshot = await firestore.collection("TempCollection").doc(uniqueId).get();
+        let itemDetailsDoc: any = itemDetailsList_snapshot.data();
+        const summary = JSON.parse(itemDetailsDoc.summary);
+        const compareStr = summary[0]["Roll No"];
+        if (compareStr === fullTakaId) {
+            return true; 
+        } else {
+            return false;
+        }
+    }
+
+    static async createResponseToSend(summary: any, serialNo: number, message: string) {
+        if (summary.length) {
+            const countRow = await this.createCountRow(summary, serialNo);
+            summary.push(countRow);
+        }
+        const result = {
+            data: JSON.stringify(summary),
+            message: message
+        }
+        return result;
+    }
+    
+    static async resetReferenceDoc(arrayInstance: any, docFromDB: any, fullTakaId: string) {
+        await docFromDB.ref.update({
+            takaList: arrayInstance.arrayUnion(fullTakaId),
+            alreadyScannedTakaId: arrayInstance.arrayRemove(fullTakaId),
+        })
+    }
+
+    static async matchTakaInTakaList(takaId: string, takaList: string[], scanType: string) {
+        let count = 0;
+        const result = {
+            status: "",
+            id : ""
+        }
+        let idToSave: string = "";
+        for (let fullId of takaList) {
+            let compareStr = fullId;
+            if (scanType === "partial") {
+                compareStr = fullId.split("-")[2];
+            }
+            if (compareStr === takaId) {
+                idToSave = fullId;
+                count++;
+            }
+        }
+        if(count === 0) {
+            result.status = "not found";
+        } else if (count === 1) {
+            result.status = "Success";
+            result.id = idToSave;
+        } else {
+            result.status = "duplicate found";
+        }
+        return result;
+    }
+
+    static async verifyTakaNUpdate(firestore: admin.firestore.Firestore, takaNo: string, uniqueId: string,
+                            arrayInstance: any, payLoadInfo: any, gradeInfoList: any) {
+        takaNo = takaNo.toUpperCase();
+        const infoDoc = await firestore.collection("TempCollection").doc(uniqueId).get();
+        const soDetails: any = infoDoc.data();
+        let summary = soDetails.summary;
+        for (let i = 0; i < soDetails.takaList.length; 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)
+                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) {
+                    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)
+                return {
+                    data: summary,
+                    message: "Scan successfully"
+                };
+            }
+        }
+        if (summary.length) {
+            const totalRow = await this.createTotalRow(summary);
+            summary.push(totalRow);
+        }
+        summary = JSON.stringify(summary);
+        return {
+            data: summary,
+            message: "Please verify the taka number with the system"
+        }
+    }
+    
+    static async getGradeFromId(id: string, gradeInfoList: any) {
+        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++) {
+            let obj = takaDetails[j];
+            if (obj.taka_no === currTaka) {
+               return {
+                    serialNo: oldSummary.length + 1,
+                    ...obj,
+                    grade: await this.getGradeFromId(obj.grade, gradeInfoList),
+               };
+            }
+        }
+        return null;
+    }
+
+    static async createTotalRow(summary: any) {
+        const totalRow: any = {};
+        let totalMeter = 0;
+        for (let row of summary) {
+            totalMeter += Number(Number(row.meter).toFixed(3));
+        }
+        totalRow.lot_no = "Total";
+        totalRow.meter = totalMeter;
+        totalRow.taka_no = summary.length;
+        totalRow.grade = "-";
+        return totalRow;
+    }
+
+    static async createResponseObj(responseInfo: any,takaId:string,serialNo:string) {
+        let resObj: any = {
+            status: false,
+            info: {}
+        };
+        for (let itemDetails of responseInfo.itemDetailsList) {
+            for (let takaDetailsObj of itemDetails.takasDetails) {
+                if (takaId === takaDetailsObj.taka_no) {
+                    if (itemDetails.P2 === takaDetailsObj.grade) {
+                        resObj.status = true;
+                    } else {
+                        return resObj;
+                    }
+                    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));
+                    resObj.info["Design"] = itemDetails.item;
+                    resObj.info["Color"] = itemDetails.P1;
+                    resObj.info["Grade"] = itemDetails.P2;
+                }
+            }
+        }
+        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 createTempCollectionOnlyWithSerialNo(firestore:admin.firestore.Firestore,uniqueId:string,doc:any){
+        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 isDocPresent(firestore:admin.firestore.Firestore,uniqueId:string){
+        let docSnapshot = await firestore.collection("TempCollection").doc(uniqueId).get()
+        return docSnapshot.exists
+    }
+
+    static async getDocInfo(firestore: admin.firestore.Firestore, uniqueId: string) {
+        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"
+    }
+
+}
+
+export { TempCollection }