shareneus 1.0.5

package/dist/services/est.print-service.js

@@ -0,0 +1,1053 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EstPrintService = void 0;
+const aggregation_1 = require("../aggregation/aggregation");
+const code_enums_1 = require("../enums/code-enums");
+const enums_1 = require("../enums/enums");
+const my_date_1 = require("../utils/my-date");
+const tr_utils_1 = require("../utils/tr-utils");
+const ro_totals_service_1 = require("./ro-totals.service");
+const shared_print_service_1 = require("./shared-print.service");
+class EstPrintService {
+    static GetEstimatePrintInfo(OriginalROData, OriginalCustomerData, OriginalVehicleData, OriginalEntityData, image, Payee, InsCompanyName, AsCustomerOnly, AsInsuranceOnly, AsCustomerAndInsurance, AsInsuranceOrCustomer, TaxCodes, OverallEst, SuppEstIndex, AsEstimated, isInitial, isReverse, Consolidate) {
+        let ROPrintData = {};
+        let argROData = tr_utils_1.TrUtils.Stringify(OriginalROData);
+        argROData.Comps = tr_utils_1.TrUtils.IsNull(argROData.Comps) ? [] : argROData.Comps;
+        argROData.Ops = tr_utils_1.TrUtils.IsNull(argROData.Ops) ? [] : argROData.Ops;
+        argROData.Parts = tr_utils_1.TrUtils.IsNull(argROData.Parts) ? [] : argROData.Parts;
+        argROData.Colli = tr_utils_1.TrUtils.IsNull(argROData.Colli) ? [] : argROData.Colli;
+        let IncludeGST = tr_utils_1.TrUtils.isTaxable(argROData.Settings.Tax);
+        ROPrintData = this.GetROBasicDetailsForPrint(ROPrintData, argROData, OriginalVehicleData, OverallEst, isInitial);
+        let SType;
+        if (!tr_utils_1.TrUtils.IsNull(OriginalROData.Settings) && !tr_utils_1.TrUtils.IsNull(OriginalROData.Settings.PoS)) {
+            SType = OriginalROData.Settings.PoS.SType;
+        }
+        ROPrintData = this.GetPrintConditionsBasedOnInput(ROPrintData, IncludeGST, Payee, AsCustomerOnly, AsInsuranceOnly, AsCustomerAndInsurance, AsInsuranceOrCustomer, SType, Consolidate);
+        ROPrintData.Entity = shared_print_service_1.PrintSharedService.GetFormattedEntityDataForPrint(OriginalEntityData, "Estimate", OriginalROData);
+        ROPrintData = shared_print_service_1.PrintSharedService.GetEntityHeaderStyles(ROPrintData, OriginalEntityData, image);
+        if (Payee === enums_1.PayTypeEnum.Insurance) {
+            ROPrintData = this.GetInsDetailsForPrint(ROPrintData, InsCompanyName, argROData, AsEstimated);
+        }
+        argROData = this.IfInitialEstimateChangeStatus(argROData, AsEstimated);
+        argROData = this.CheckStatusAndChangeDeclinedItemsToNew(argROData);
+        argROData = this.GetValidItemsForTotals(argROData);
+        if (!OverallEst) {
+            argROData = this.GetItemsBySuppEstIndex(argROData, SuppEstIndex);
+            if (!tr_utils_1.TrUtils.IsNull(SuppEstIndex)) {
+                let Index = argROData.SuppEst.findIndex((supp) => {
+                    return supp.Id === SuppEstIndex;
+                });
+                if (Index !== -1 && !tr_utils_1.TrUtils.IsNull(argROData.SuppEst[Index].Date)) {
+                    ROPrintData.CrDate = my_date_1.MyDate.ConvertUTCDateToReadable(argROData.SuppEst[Index].Date);
+                }
+            }
+        }
+        argROData.Ops = this.SeparateROLaborByPType(argROData.Ops, Payee, AsCustomerOnly, AsInsuranceOnly, AsEstimated);
+        argROData.Parts = this.SeparateROPartsByPType(argROData.Parts, Payee, AsCustomerOnly, AsInsuranceOnly, AsEstimated);
+        argROData.Colli = this.SeparateROCollisionsByItems(argROData.Colli, argROData.Ops, argROData.Parts);
+        // argROData = this.ResetDescForPrint(argROData);
+        argROData.Parts = this.ResetQtyAndUoM(argROData.Parts);
+        if (AsInsuranceOnly || AsCustomerAndInsurance || AsInsuranceOrCustomer) {
+            ROPrintData.ShowAccParts = true;
+        }
+        else {
+            ROPrintData.ShowAccParts = this.CheckAndShowItemsAsAR(argROData);
+        }
+        argROData = this.ReverseItemsForROPrint(argROData, isReverse);
+        let finalTotalsData = ro_totals_service_1.ROTotalsService.GetTotalsValue(argROData, TaxCodes, false, true, true, ROPrintData.Entity.Round);
+        finalTotalsData = this.CheckAndGetCombinedTotals(AsCustomerAndInsurance, AsInsuranceOrCustomer, finalTotalsData);
+        finalTotalsData.Settings = tr_utils_1.TrUtils.Stringify(argROData.Settings);
+        if (AsCustomerOnly) {
+            if (ROPrintData.ShowAccParts) {
+                finalTotalsData = this.GetLaborAndPartItemsAfterDisc(finalTotalsData);
+            }
+            else {
+                finalTotalsData = this.GetDetailedInfoForItems(finalTotalsData);
+                finalTotalsData = this.GetCustTaxInfo(finalTotalsData, IncludeGST, TaxCodes);
+            }
+        }
+        if (AsCustomerAndInsurance) {
+            finalTotalsData = this.GetCombinedInfoForItems(finalTotalsData);
+        }
+        if (AsInsuranceOrCustomer) {
+            finalTotalsData.Parts = this.GetSplitInfoForParts(finalTotalsData.Parts);
+        }
+        if (IncludeGST) {
+            finalTotalsData.ShowDetailedLaborTaxInfo = this.CheckLaborTaxItemIndex(finalTotalsData.Ops) !== -1;
+            finalTotalsData.ShowDetailedPartTaxInfo = this.CheckPartTaxItemIndex(finalTotalsData.Parts) !== -1;
+        }
+        else {
+            finalTotalsData.ShowDetailedLaborTaxInfo = false;
+            finalTotalsData.ShowDetailedPartTaxInfo = false;
+        }
+        ROPrintData = tr_utils_1.TrUtils.ConcatObjects(ROPrintData, finalTotalsData);
+        if (ROPrintData.ShowAccParts) {
+            ROPrintData = this.ConvertItemsAsAR(ROPrintData, Consolidate);
+        }
+        ROPrintData.Colli = this.EmptyInvalidCollisionRepairItems(ROPrintData.Colli);
+        ROPrintData = this.GetLineTotals(ROPrintData, IncludeGST, AsCustomerOnly, AsInsuranceOnly, Consolidate);
+        ROPrintData.PrintInfo = this.PrepareFormatForEstPrint(ROPrintData, SuppEstIndex, OverallEst, code_enums_1.ROTypeEnum.Estimate, AsEstimated);
+        ROPrintData = this.CheckAndCombineDescMPNForAR(ROPrintData.Entity.MPN, ROPrintData);
+        ROPrintData.Vehicle = shared_print_service_1.PrintSharedService.GetVehicleFromServiceAndFormatData(OriginalVehicleData);
+        ROPrintData.Customer = shared_print_service_1.PrintSharedService.GetCustomerFromServiceAndFormatData(OriginalCustomerData);
+        if ((Payee === enums_1.PayTypeEnum.Customer || AsCustomerOnly) && !ROPrintData.ConsolidateGST) {
+            // if (PrintSharedService.CheckItemIndexWithDisc(ROPrintData) !== -1) {
+            ROPrintData.ShowDiscountColumn = (ROPrintData.Settings.DiscLvl === 'ITM' || ROPrintData.Settings.DiscLvl === 'RECITM') ? true : false;
+            // }
+        }
+        return ROPrintData;
+    }
+    static GetROBasicDetailsForPrint(ROPrintData, argROData, Product, OverallEst, isInitial) {
+        ROPrintData.CrDate = my_date_1.MyDate.ConvertUTCDateToReadable(argROData.CrDate);
+        if (!isInitial) {
+            ROPrintData.PrDate = my_date_1.MyDate.ConvertUTCDateToReadable(argROData.PrDate);
+        }
+        else {
+            delete ROPrintData.PrDate;
+        }
+        ROPrintData.MIn = Product.MIn;
+        ROPrintData._id = argROData.Code;
+        if (isInitial || tr_utils_1.TrUtils.IsNull(argROData.SuppEst) || argROData.SuppEst.length === 0 || OverallEst) {
+            ROPrintData.Type = 'Estimate';
+            ROPrintData.HeaderName = 'Estimate';
+        }
+        else {
+            ROPrintData.Type = 'Supplementary Estimate';
+            ROPrintData.HeaderName = 'Supplementary Estimate';
+        }
+        ROPrintData.SuppEst = argROData.SuppEst;
+        return ROPrintData;
+    }
+    static GetPrintConditionsBasedOnInput(ROPrintData, IncludeGST, Payee, AsCustomerOnly, AsInsuranceOnly, AsCustomerAndInsurance, AsInsuranceOrCustomer, SType, Consolidate) {
+        ROPrintData.Payee = Payee;
+        ROPrintData.AsCustomerOnly = AsCustomerOnly;
+        ROPrintData.AsInsuranceOnly = AsInsuranceOnly;
+        ROPrintData.AsCustomerAndInsurance = AsCustomerAndInsurance;
+        ROPrintData.AsInsuranceOrCustomer = AsInsuranceOrCustomer;
+        ROPrintData.IncludeGST = IncludeGST;
+        ROPrintData.ConsolidateGST = Consolidate;
+        ROPrintData.Consolidate = Consolidate;
+        ROPrintData.ShowIGST = (tr_utils_1.TrUtils.IsNull(SType) || (SType === 'Intra')) ? false : true;
+        ROPrintData.ShowTaxColumn = (IncludeGST && !Consolidate) ? true : false;
+        // ROPrintData.ShowDiscountColumn = (Payee === PayTypeEnum.Customer || AsCustomerOnly) ? true : false;
+        return ROPrintData;
+    }
+    static GetInsDetailsForPrint(ROPrintData, InsCompanyName, argROData, AsEstimated) {
+        if (tr_utils_1.TrUtils.IsNull(argROData.Ins)) {
+            argROData.Ins = this.GetDefualtInsData();
+        }
+        ROPrintData.InsComp = InsCompanyName;
+        if (!AsEstimated) {
+            ROPrintData.SurName = argROData.Ins.SName;
+            ROPrintData.SurEmail = argROData.Ins.SEmail;
+            ROPrintData.SurPhone = argROData.Ins.SPhone;
+        }
+        ROPrintData.PolType = argROData.Ins.Type;
+        ROPrintData.PolNo = argROData.Ins.PolNo;
+        return ROPrintData;
+    }
+    static GetDefualtInsData() {
+        let ROInsData = {
+            SName: '',
+            SEmail: '',
+            SPhone: '',
+            PolNo: ''
+        };
+        return ROInsData;
+    }
+    static IfInitialEstimateChangeStatus(argROData, AsEstimated) {
+        if (AsEstimated) {
+            argROData.Sts = enums_1.ROStatusEnum.New;
+            argROData.Ops = this.ChangeLaborStatusToNew(argROData.Ops);
+            argROData.Parts = this.ChangePartStatusToNew(argROData.Parts);
+            argROData.Colli = this.ChangeColliStatusToNew(argROData.Colli);
+        }
+        return argROData;
+    }
+    static ChangeLaborStatusToNew(Operations) {
+        Operations.forEach((Labor) => {
+            Labor.Sts = enums_1.LaborStatusEnum.New;
+        });
+        return Operations;
+    }
+    static ChangePartStatusToNew(Parts) {
+        Parts.forEach((Part) => {
+            if (!tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                Part.Sts = enums_1.LaborStatusEnum.New;
+            }
+        });
+        return Parts;
+    }
+    static ChangeColliStatusToNew(Collisions) {
+        Collisions.forEach((Collision) => {
+            Collision.Sts = enums_1.LaborStatusEnum.New;
+        });
+        return Collisions;
+    }
+    static CheckStatusAndChangeDeclinedItemsToNew(argROData) {
+        if (argROData.Sts === enums_1.ROStatusEnum.New || argROData.Sts === enums_1.ROStatusEnum.WtngForAppr) {
+            argROData = this.ChangeDeclinedStatusToNew(argROData);
+        }
+        return argROData;
+    }
+    static ChangeDeclinedStatusToNew(argROData) {
+        argROData.Ops = this.ChangeDeclinedLaborStatusToNew(argROData.Ops);
+        argROData.Parts = this.ChangeDeclinedPartStatusToNew(argROData.Parts);
+        argROData.Colli = this.ChangeDeclinedColliStatusToNew(argROData.Colli);
+        return argROData;
+    }
+    static ChangeDeclinedLaborStatusToNew(Operations) {
+        Operations.forEach((Labor) => {
+            if (Labor.Sts === enums_1.LaborStatusEnum.Declined) {
+                Labor.Sts = enums_1.LaborStatusEnum.New;
+            }
+        });
+        return Operations;
+    }
+    static ChangeDeclinedPartStatusToNew(Parts) {
+        Parts.forEach((Part) => {
+            if (!tr_utils_1.TrUtils.IsNull(Part.CollId) && Part.Sts === enums_1.LaborStatusEnum.Declined) {
+                Part.Sts = enums_1.LaborStatusEnum.New;
+            }
+        });
+        return Parts;
+    }
+    static ChangeDeclinedColliStatusToNew(Collisions) {
+        Collisions.forEach((Collision) => {
+            if (Collision.Sts === enums_1.LaborStatusEnum.Declined) {
+                Collision.Sts = enums_1.LaborStatusEnum.New;
+            }
+        });
+        return Collisions;
+    }
+    static GetValidItemsForTotals(RecordData) {
+        let RecordStatus = RecordData.Sts;
+        RecordData.Ops = this.GetLaborByRecordAndLaborStatus(RecordStatus, RecordData.Ops);
+        RecordData.Parts = this.GetPartsByRecordAndPartStatus(RecordStatus, RecordData.Parts);
+        RecordData.Colli = this.GetCollisionByRecordAndColliStatus(RecordStatus, RecordData.Colli);
+        return RecordData;
+    }
+    static GetLaborByRecordAndLaborStatus(RecordStatus, Operations) {
+        if (RecordStatus === enums_1.ROStatusEnum.Cancelled || RecordStatus === enums_1.ROStatusEnum.Declined) {
+            return Operations;
+        }
+        else {
+            return this.GetValidROLaborListByStatus(Operations);
+        }
+    }
+    static GetValidROLaborListByStatus(Operations) {
+        let opCodesList = Operations.filter((Operation) => {
+            if (this.CheckOperationHasActiveStatus(Operation.Sts)) {
+                return Operation;
+            }
+        });
+        return opCodesList;
+    }
+    static CheckOperationHasActiveStatus(Status) {
+        return (Status !== enums_1.LaborStatusEnum.Cancelled && Status !== enums_1.LaborStatusEnum.Declined) ? true : false;
+    }
+    static GetPartsByRecordAndPartStatus(RecordStatus, Parts) {
+        if (RecordStatus === enums_1.ROStatusEnum.Cancelled || RecordStatus === enums_1.ROStatusEnum.Declined) {
+            return Parts;
+        }
+        else {
+            return this.GetValidROPartsListByStatus(Parts);
+        }
+    }
+    static GetValidROPartsListByStatus(Parts) {
+        let PartsList = Parts.filter((Part) => {
+            if (tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                return Part;
+            }
+            else {
+                if (this.CheckOperationHasActiveStatus(Part.Sts)) {
+                    return Part;
+                }
+            }
+        });
+        return PartsList;
+    }
+    static GetCollisionByRecordAndColliStatus(RecordStatus, Collisions) {
+        if (RecordStatus === enums_1.ROStatusEnum.Cancelled || RecordStatus === enums_1.ROStatusEnum.Declined) {
+            return Collisions;
+        }
+        else {
+            return this.GetValidROCollisionListByStatus(Collisions);
+        }
+    }
+    static GetValidROCollisionListByStatus(Collisions) {
+        let collList = Collisions.filter((Collision) => {
+            if (this.CheckOperationHasActiveStatus(Collision.Sts)) {
+                return Collision;
+            }
+        });
+        return collList;
+    }
+    static GetItemsBySuppEstIndex(argROData, SuppEstIndex) {
+        if (tr_utils_1.TrUtils.IsNull(SuppEstIndex)) {
+            SuppEstIndex = null;
+        }
+        argROData.Ops = argROData.Ops.filter((Labor) => {
+            if (tr_utils_1.TrUtils.IsNull(Labor.SuppEst)) {
+                Labor.SuppEst = null;
+            }
+            return Labor.SuppEst === SuppEstIndex;
+        });
+        argROData.Parts = argROData.Parts.filter((Part) => {
+            if (tr_utils_1.TrUtils.IsNull(Part.SuppEst)) {
+                Part.SuppEst = null;
+            }
+            return Part.SuppEst === SuppEstIndex;
+        });
+        argROData.Colli = argROData.Colli.filter((Collision) => {
+            if (tr_utils_1.TrUtils.IsNull(Collision.SuppEst)) {
+                Collision.SuppEst = null;
+            }
+            return Collision.SuppEst === SuppEstIndex;
+        });
+        return argROData;
+    }
+    static SeparateROLaborByPType(Labors, PType, CustomerOnly, InsuranceOnly, AsEstimated) {
+        let LaborList = [];
+        LaborList = Labors.filter((Labor) => {
+            if (AsEstimated) {
+                if (PType === enums_1.PayTypeEnum.Customer) {
+                    return Labor.PBy === enums_1.PayTypeEnum.Customer;
+                }
+                else {
+                    return (Labor.PBy === enums_1.PayTypeEnum.Insurance || Labor.PBy === enums_1.PayTypeEnum.Shared);
+                }
+            }
+            else {
+                if (PType === enums_1.PayTypeEnum.Customer) {
+                    return Labor.PBy === PType;
+                }
+                else {
+                    if (CustomerOnly) {
+                        return (Labor.PBy === enums_1.PayTypeEnum.Shared) && !tr_utils_1.TrUtils.IsZero(Labor.Pr);
+                    }
+                    else {
+                        if (InsuranceOnly) {
+                            return (Labor.PBy === enums_1.PayTypeEnum.Insurance || Labor.PBy === enums_1.PayTypeEnum.Shared) && !tr_utils_1.TrUtils.IsZero(Labor.AssPr);
+                        }
+                        else {
+                            return (Labor.PBy === enums_1.PayTypeEnum.Insurance || Labor.PBy === enums_1.PayTypeEnum.Shared);
+                        }
+                    }
+                }
+            }
+        });
+        return LaborList;
+    }
+    static SeparateROPartsByPType(Parts, PType, CustomerOnly, InsuranceOnly, AsEstimated) {
+        let PartsList = [];
+        PartsList = Parts.filter((Part) => {
+            if (AsEstimated) {
+                if (PType === enums_1.PayTypeEnum.Customer) {
+                    return Part.PBy === PType;
+                }
+                else {
+                    return (Part.PBy === enums_1.PayTypeEnum.Insurance || Part.PBy === enums_1.PayTypeEnum.Shared);
+                }
+            }
+            else {
+                if (PType === enums_1.PayTypeEnum.Customer) {
+                    return Part.PBy === PType;
+                }
+                else {
+                    if (CustomerOnly) {
+                        return (Part.PBy === enums_1.PayTypeEnum.Shared) && !tr_utils_1.TrUtils.IsZero(Part.UnPr);
+                    }
+                    else {
+                        if (InsuranceOnly) {
+                            return (Part.PBy === enums_1.PayTypeEnum.Insurance || Part.PBy === enums_1.PayTypeEnum.Shared) && !tr_utils_1.TrUtils.IsZero(Part.AssPr);
+                        }
+                        else {
+                            return (Part.PBy === enums_1.PayTypeEnum.Insurance || Part.PBy === enums_1.PayTypeEnum.Shared);
+                        }
+                    }
+                }
+            }
+        });
+        return PartsList;
+    }
+    static SeparateROCollisionsByItems(Collisions, Ops, Parts) {
+        let CollisionList = Collisions.filter((Collision) => {
+            let LaborIndex = Ops.findIndex((Labor) => {
+                return Labor.CollId === Collision._id;
+            });
+            let PartIndex = Parts.findIndex((Part) => {
+                return Part.CollId === Collision._id;
+            });
+            if (LaborIndex !== -1 || PartIndex !== -1) {
+                return Collision;
+            }
+        });
+        return CollisionList;
+    }
+    static ResetQtyAndUoM(Parts) {
+        Parts.forEach((Item) => {
+            if (!tr_utils_1.TrUtils.IsZero(Item.Qty) && !tr_utils_1.TrUtils.CheckInvalidSelect(Item.UoM)) {
+                Item.QtyAndUoM = Item.Qty + ' ' + Item.UoM;
+            }
+        });
+        return Parts;
+    }
+    static CheckAndShowItemsAsAR(argROData) {
+        let AccPartsIndex = argROData.Parts.findIndex((Part) => {
+            return !tr_utils_1.TrUtils.IsNull((Part.CollId));
+        });
+        let InsLaborIndex = argROData.Ops.findIndex((Labor) => {
+            return !tr_utils_1.TrUtils.IsNull((Labor.CollId));
+        });
+        if (AccPartsIndex !== -1 || InsLaborIndex !== -1) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    static ConvertItemsAsAR(ROPrintData, Consolidate) {
+        ROPrintData.Colli.forEach((Collision) => {
+            Collision = this.ResetItemsDataById(Collision, ROPrintData.Ops, ROPrintData.Parts);
+        });
+        ROPrintData.Ops.forEach((Labor) => {
+            // console.log('Labor', Labor);
+            Labor.NetAmt = tr_utils_1.TrUtils.FixPriceValue(Labor.NetAmt);
+            Labor.CCGST = tr_utils_1.TrUtils.FixPriceValue(Labor.CCGST);
+            Labor.CSGST = tr_utils_1.TrUtils.FixPriceValue(Labor.CSGST);
+            Labor.CIGST = tr_utils_1.TrUtils.FixPriceValue(Labor.CIGST);
+            Labor.Disc = tr_utils_1.TrUtils.FixPriceValue(Labor.Disc);
+            Labor.AssPr = tr_utils_1.TrUtils.FixPriceValue(Labor.AssPr);
+            Labor.ACGST = tr_utils_1.TrUtils.FixPriceValue(Labor.ACGST);
+            Labor.ASGST = tr_utils_1.TrUtils.FixPriceValue(Labor.ASGST);
+            Labor.AIGST = tr_utils_1.TrUtils.FixPriceValue(Labor.AIGST);
+            if (Consolidate) {
+                if (Labor.PBy === enums_1.PayTypeEnum.Customer) {
+                    Labor.EstPr = tr_utils_1.TrUtils.FixPriceValue(Labor.CustAfterTax);
+                    Labor.Pr = tr_utils_1.TrUtils.FixPriceValue(Labor.CustAfterTax);
+                }
+                else {
+                    Labor.EstPr = tr_utils_1.TrUtils.FixPriceValue(Labor.InsAfterTax);
+                    Labor.Pr = tr_utils_1.TrUtils.FixPriceValue(Labor.InsAfterTax);
+                }
+            }
+            else {
+                Labor.EstPr = tr_utils_1.TrUtils.FixPriceValue(Labor.EstPr);
+                Labor.Pr = tr_utils_1.TrUtils.FixPriceValue(Labor.Pr);
+            }
+            Labor.ECGST = tr_utils_1.TrUtils.FixPriceValue(Labor.ECGST);
+            Labor.ESGST = tr_utils_1.TrUtils.FixPriceValue(Labor.ESGST);
+            Labor.EIGST = tr_utils_1.TrUtils.FixPriceValue(Labor.EIGST);
+            if (tr_utils_1.TrUtils.IsNull(Labor.CollId)) {
+                let LaborColli = {
+                    _id: Labor._id,
+                    Desc: Labor.Desc,
+                    PBy: Labor.PBy,
+                    Op_Id: Labor.Op_Id,
+                    Qty: 0,
+                    Sts: Labor.Sts
+                };
+                LaborColli.RRFData = Labor;
+                LaborColli.SuppEst = Labor.SuppEst;
+                ROPrintData.Colli.push(LaborColli);
+            }
+        });
+        ROPrintData.Parts.forEach((Part) => {
+            // console.log('Part', Part);
+            Part.NetAmt = tr_utils_1.TrUtils.FixPriceValue(Part.NetAmt);
+            Part.UnAmt = tr_utils_1.TrUtils.FixPriceValue(Part.UnAmt);
+            Part.CCGST = tr_utils_1.TrUtils.FixPriceValue(Part.CCGST);
+            Part.CSGST = tr_utils_1.TrUtils.FixPriceValue(Part.CSGST);
+            Part.CIGST = tr_utils_1.TrUtils.FixPriceValue(Part.CIGST);
+            Part.Disc = tr_utils_1.TrUtils.FixPriceValue(Part.Disc);
+            Part.AssPr = tr_utils_1.TrUtils.FixPriceValue(Part.AssPr);
+            Part.AssAmt = tr_utils_1.TrUtils.FixPriceValue(Part.AssAmt);
+            Part.ACGST = tr_utils_1.TrUtils.FixPriceValue(Part.ACGST);
+            Part.ASGST = tr_utils_1.TrUtils.FixPriceValue(Part.ASGST);
+            Part.AIGST = tr_utils_1.TrUtils.FixPriceValue(Part.AIGST);
+            Part.EstPr = tr_utils_1.TrUtils.FixPriceValue(Part.EstPr);
+            if (Consolidate) {
+                if (Part.PBy === enums_1.PayTypeEnum.Customer) {
+                    Part.EstPr = tr_utils_1.TrUtils.FixPriceValue(Part.CustAfterTax / Part.Qty);
+                    Part.UnPr = tr_utils_1.TrUtils.FixPriceValue(Part.CustAfterTax / Part.Qty);
+                }
+                else {
+                    Part.EstPr = tr_utils_1.TrUtils.FixPriceValue(Part.InsAfterTax / Part.Qty);
+                    Part.UnPr = tr_utils_1.TrUtils.FixPriceValue(Part.InsAfterTax / Part.Qty);
+                }
+            }
+            else {
+                Part.EstPr = tr_utils_1.TrUtils.FixPriceValue(Part.EstPr);
+                Part.UnPr = tr_utils_1.TrUtils.FixPriceValue(Part.UnPr);
+            }
+            Part.EstAmt = tr_utils_1.TrUtils.FixPriceValue(Part.EstAmt);
+            Part.ECGST = tr_utils_1.TrUtils.FixPriceValue(Part.ECGST);
+            Part.ESGST = tr_utils_1.TrUtils.FixPriceValue(Part.ESGST);
+            Part.EIGST = tr_utils_1.TrUtils.FixPriceValue(Part.EIGST);
+            if (tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                let LaborIndex = ROPrintData.Ops.findIndex((Labor) => {
+                    return Labor._id === Part.OpId;
+                });
+                let OpsStatus = ROPrintData.Ops[LaborIndex].Sts;
+                let PartColli = {
+                    _id: Part._id,
+                    Desc: Part.Desc,
+                    PBy: Part.PBy,
+                    Sts: OpsStatus
+                };
+                PartColli.PartData = Part;
+                PartColli.SuppEst = Part.SuppEst;
+                ROPrintData.Colli.push(PartColli);
+            }
+        });
+        ROPrintData.Ops = [];
+        ROPrintData.Parts = [];
+        return ROPrintData;
+    }
+    static ResetItemsDataById(Collision, AddedOperations, AddedParts) {
+        Collision.PartData = tr_utils_1.TrUtils.IsNull(Collision.PartId)
+            ? null : this.GetPartDataById(Collision.PartId, AddedParts);
+        Collision.RRFData = tr_utils_1.TrUtils.IsNull(Collision.RRFId)
+            ? null : this.GetLaborDataById(Collision.RRFId, AddedOperations);
+        Collision.PtngData = tr_utils_1.TrUtils.IsNull(Collision.PainId)
+            ? null : this.GetLaborDataById(Collision.PainId, AddedOperations);
+        Collision.DtngData = tr_utils_1.TrUtils.IsNull(Collision.RepId)
+            ? null : this.GetLaborDataById(Collision.RepId, AddedOperations);
+        return Collision;
+    }
+    static GetPartDataById(PartId, AddedParts) {
+        let partIndex = AddedParts.findIndex((Part) => {
+            return Part._id === PartId;
+        });
+        return (partIndex !== -1) ? AddedParts[partIndex] : null;
+    }
+    static GetLaborDataById(LaborId, AddedOperations) {
+        let laborIndex = AddedOperations.findIndex((Labor) => {
+            return Labor._id === LaborId;
+        });
+        return (laborIndex !== -1) ? AddedOperations[laborIndex] : null;
+    }
+    static EmptyInvalidCollisionRepairItems(Colli) {
+        Colli.forEach((CollisionItem) => {
+            if (!tr_utils_1.TrUtils.IsNull(CollisionItem.PartData) && !this.CheckOperationHasActiveStatus(CollisionItem.PartData.Sts)) {
+                CollisionItem.PartData.EstPr = null;
+                CollisionItem.PartData.AssPr = null;
+                CollisionItem.PartData.UnPr = null;
+                CollisionItem.PartData.Disc = 0;
+                CollisionItem.PartData.RecDisc = 0;
+            }
+            if (!tr_utils_1.TrUtils.IsNull(CollisionItem.RRFData) && !this.CheckOperationHasActiveStatus(CollisionItem.RRFData.Sts)) {
+                CollisionItem.RRFData.EstPr = null;
+                CollisionItem.RRFData.AssPr = null;
+                CollisionItem.RRFData.Pr = null;
+                CollisionItem.RRFData.Disc = 0;
+                CollisionItem.RRFData.RecDisc = 0;
+            }
+            if (!tr_utils_1.TrUtils.IsNull(CollisionItem.DtngData) && !this.CheckOperationHasActiveStatus(CollisionItem.DtngData.Sts)) {
+                CollisionItem.DtngData.EstPr = null;
+                CollisionItem.DtngData.AssPr = null;
+                CollisionItem.DtngData.Pr = null;
+                CollisionItem.DtngData.Disc = 0;
+                CollisionItem.DtngData.RecDisc = 0;
+            }
+            if (!tr_utils_1.TrUtils.IsNull(CollisionItem.PtngData) && !this.CheckOperationHasActiveStatus(CollisionItem.PtngData.Sts)) {
+                CollisionItem.PtngData.EstPr = null;
+                CollisionItem.PtngData.AssPr = null;
+                CollisionItem.PtngData.Pr = null;
+                CollisionItem.PtngData.Disc = 0;
+                CollisionItem.PtngData.RecDisc = 0;
+            }
+        });
+        return Colli;
+    }
+    static GetLineTotals(ROPrintData, IncludeGST, AsCustomerOnly, AsInsuranceOnly, Consolidate) {
+        ROPrintData.Ops.forEach((Labor) => {
+            Labor.LineTotal = this.GetLaborLineTotal(Labor, IncludeGST, AsCustomerOnly, AsInsuranceOnly, Consolidate);
+        });
+        ROPrintData.Parts.forEach((Part) => {
+            Part.LineTotal = this.GetPartLineTotal(Part, IncludeGST, AsCustomerOnly, AsInsuranceOnly, Consolidate);
+        });
+        ROPrintData.Colli.forEach((Collision) => {
+            let LineTotal = 0;
+            if (!tr_utils_1.TrUtils.IsNull(Collision.PartData)) {
+                LineTotal += this.GetCollisionPartLineTotal(Collision.PartData, AsCustomerOnly, AsInsuranceOnly, Consolidate);
+            }
+            if (!tr_utils_1.TrUtils.IsNull(Collision.RRFData)) {
+                LineTotal += this.GetCollisionLaborLineTotal(Collision.RRFData, AsCustomerOnly, AsInsuranceOnly, Consolidate);
+            }
+            if (!tr_utils_1.TrUtils.IsNull(Collision.PtngData)) {
+                LineTotal += this.GetCollisionLaborLineTotal(Collision.PtngData, AsCustomerOnly, AsInsuranceOnly, Consolidate);
+            }
+            if (!tr_utils_1.TrUtils.IsNull(Collision.DtngData)) {
+                LineTotal += this.GetCollisionLaborLineTotal(Collision.DtngData, AsCustomerOnly, AsInsuranceOnly, Consolidate);
+            }
+            Collision.LineTotal = tr_utils_1.TrUtils.FixPriceValue(LineTotal);
+        });
+        return ROPrintData;
+    }
+    static GetCollisionPartLineTotal(PartData, AsCustomerOnly, AsInsuranceOnly, Consolidate) {
+        let LineTotal = 0;
+        if (AsCustomerOnly) {
+            if (Consolidate) {
+                LineTotal = PartData.CustAfterTax;
+            }
+            else {
+                LineTotal = PartData.CustAfterPartDisc;
+            }
+        }
+        else if (AsInsuranceOnly) {
+            if (Consolidate) {
+                LineTotal = PartData.InsAfterTax;
+            }
+            else {
+                LineTotal = PartData.InsAfterPartDisc;
+            }
+        }
+        else {
+            if (Consolidate) {
+                LineTotal = PartData.InsAfterTax + PartData.CustAfterTax;
+            }
+            else {
+                LineTotal = PartData.InsAfterPartDisc + PartData.CustAfterPartDisc;
+            }
+        }
+        return LineTotal;
+    }
+    static GetCollisionLaborLineTotal(LaborData, AsCustomerOnly, AsInsuranceOnly, Consolidate) {
+        let LineTotal = 0;
+        if (AsCustomerOnly) {
+            if (Consolidate) {
+                LineTotal = LaborData.CustAfterTax;
+            }
+            else {
+                LineTotal = LaborData.CustAfterLaborDisc;
+            }
+        }
+        else if (AsInsuranceOnly) {
+            if (Consolidate) {
+                LineTotal = LaborData.InsAfterTax;
+            }
+            else {
+                LineTotal = LaborData.InsAfterLaborDisc;
+            }
+        }
+        else {
+            if (Consolidate) {
+                LineTotal = LaborData.InsAfterTax + LaborData.CustAfterTax;
+            }
+            else {
+                LineTotal = LaborData.InsAfterLaborDisc + LaborData.CustAfterLaborDisc;
+            }
+        }
+        return LineTotal;
+    }
+    static GetLaborLineTotal(LaborData, IncludeGST, AsCustomerOnly, AsInsuranceOnly, Consolidate) {
+        let LineTotal = 0;
+        if (AsCustomerOnly) {
+            if (IncludeGST || Consolidate) {
+                LineTotal = LaborData.CustAfterTax;
+            }
+            else {
+                LineTotal = LaborData.CustAfterLaborDisc;
+            }
+        }
+        else if (AsInsuranceOnly) {
+            if (IncludeGST || Consolidate) {
+                LineTotal = LaborData.InsAfterTax;
+            }
+            else {
+                LineTotal = LaborData.InsAfterLaborDisc;
+            }
+        }
+        else {
+            if (IncludeGST || Consolidate) {
+                LineTotal = LaborData.CustAfterTax + LaborData.InsAfterTax;
+            }
+            else {
+                LineTotal = LaborData.InsAfterLaborDisc + LaborData.CustAfterLaborDisc;
+            }
+        }
+        return tr_utils_1.TrUtils.FixedTo(LineTotal);
+    }
+    static GetPartLineTotal(PartData, IncludeGST, AsCustomerOnly, AsInsuranceOnly, Consolidate) {
+        let LineTotal = 0;
+        if (AsCustomerOnly) {
+            if (IncludeGST || Consolidate) {
+                LineTotal = PartData.CustAfterTax;
+            }
+            else {
+                LineTotal = PartData.CustAfterPartDisc;
+            }
+        }
+        else if (AsInsuranceOnly) {
+            if (IncludeGST || Consolidate) {
+                LineTotal = PartData.InsAfterTax;
+            }
+            else {
+                LineTotal = PartData.InsAfterPartDisc;
+            }
+        }
+        else {
+            if (IncludeGST || Consolidate) {
+                LineTotal = PartData.InsAfterTax + PartData.CustAfterTax;
+            }
+            else {
+                LineTotal = PartData.InsAfterPartDisc + PartData.CustAfterPartDisc;
+            }
+        }
+        return tr_utils_1.TrUtils.FixedTo(LineTotal);
+    }
+    static ReverseItemsForROPrint(argROData, isReverse) {
+        if (isReverse) {
+            argROData.Comps = tr_utils_1.TrUtils.IsNull(argROData.Comps) ? [] : argROData.Comps.reverse();
+            argROData.Ops = tr_utils_1.TrUtils.IsNull(argROData.Ops) ? [] : argROData.Ops.reverse();
+            argROData.Parts = tr_utils_1.TrUtils.IsNull(argROData.Parts) ? [] : argROData.Parts.reverse();
+            argROData.Colli = tr_utils_1.TrUtils.IsNull(argROData.Colli) ? [] : argROData.Colli.reverse();
+        }
+        else {
+            argROData.Comps = tr_utils_1.TrUtils.IsNull(argROData.Comps) ? [] : argROData.Comps;
+            argROData.Ops = tr_utils_1.TrUtils.IsNull(argROData.Ops) ? [] : argROData.Ops;
+            argROData.Parts = tr_utils_1.TrUtils.IsNull(argROData.Parts) ? [] : argROData.Parts;
+            argROData.Colli = tr_utils_1.TrUtils.IsNull(argROData.Colli) ? [] : argROData.Colli;
+        }
+        let ReversedLabors = [];
+        argROData.Comps.forEach((Complaint) => {
+            argROData.Ops.forEach((Labor) => {
+                if (Labor.CompId === Complaint._id) {
+                    ReversedLabors.push(Labor);
+                }
+            });
+        });
+        argROData.Ops.forEach((Labor) => {
+            if (tr_utils_1.TrUtils.IsNull(Labor.CompId)) {
+                ReversedLabors.push(Labor);
+            }
+        });
+        argROData.Ops = ReversedLabors;
+        let ReversedParts = [];
+        argROData.Ops.forEach((Labor) => {
+            argROData.Parts.forEach((Part) => {
+                if (tr_utils_1.TrUtils.IsNull(Part.CollId) && (Part.OpId === Labor._id)) {
+                    ReversedParts.push(Part);
+                }
+            });
+        });
+        argROData.Parts.forEach((Part) => {
+            if (!tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                ReversedParts.push(Part);
+            }
+        });
+        argROData.Parts = ReversedParts;
+        return argROData;
+    }
+    static CheckAndGetCombinedTotals(AsCustomerAndInsurance, AsInsuranceOrCustomer, finalTotalsData) {
+        if (AsCustomerAndInsurance || AsInsuranceOrCustomer) {
+            finalTotalsData.InsLaborTotalBeforeDisc = tr_utils_1.TrUtils.FixPriceValue(Number(finalTotalsData.CustLaborTotalBeforeDisc) +
+                Number(finalTotalsData.InsLaborTotalBeforeDisc));
+            finalTotalsData.InsLaborDiscTotal = tr_utils_1.TrUtils.FixPriceValue(Number(finalTotalsData.CustLaborDiscTotal) +
+                Number(finalTotalsData.InsLaborDiscTotal));
+            finalTotalsData.InsLaborCGST = tr_utils_1.TrUtils.FixPriceValue(Number(finalTotalsData.CustLaborCGST) +
+                Number(finalTotalsData.InsLaborCGST));
+            finalTotalsData.InsLaborSGST = tr_utils_1.TrUtils.FixPriceValue(Number(finalTotalsData.CustLaborSGST) +
+                Number(finalTotalsData.InsLaborSGST));
+            finalTotalsData.InsLaborIGST = tr_utils_1.TrUtils.FixPriceValue(Number(finalTotalsData.CustLaborIGST) +
+                Number(finalTotalsData.InsLaborIGST));
+            finalTotalsData.InsPartIGST = tr_utils_1.TrUtils.FixPriceValue(Number(finalTotalsData.CustPartIGST) +
+                Number(finalTotalsData.InsPartIGST));
+            finalTotalsData.InsPartsTotalBeforeDisc = tr_utils_1.TrUtils.FixPriceValue(Number(finalTotalsData.CustPartsTotalBeforeDisc) +
+                Number(finalTotalsData.InsPartsTotalBeforeDisc));
+            finalTotalsData.InsPartsDiscTotal = tr_utils_1.TrUtils.FixPriceValue(Number(finalTotalsData.CustPartsDiscTotal) +
+                Number(finalTotalsData.InsPartsDiscTotal));
+            finalTotalsData.InsPartCGST = tr_utils_1.TrUtils.FixPriceValue(Number(finalTotalsData.CustPartCGST) +
+                Number(finalTotalsData.InsPartCGST));
+            finalTotalsData.InsPartSGST = tr_utils_1.TrUtils.FixPriceValue(Number(finalTotalsData.CustPartSGST) +
+                Number(finalTotalsData.InsPartSGST));
+            finalTotalsData.InsLaborTotalAfterTax = tr_utils_1.TrUtils.FixPriceValue(Number(finalTotalsData.CustLaborAfterTax) +
+                Number(finalTotalsData.InsLaborTotalAfterTax));
+            finalTotalsData.InsPartsTotalAfterTax = tr_utils_1.TrUtils.FixPriceValue(Number(finalTotalsData.CustPartAfterTax) +
+                Number(finalTotalsData.InsPartsTotalAfterTax));
+            finalTotalsData.FixedInsTotal = tr_utils_1.TrUtils.FixPriceValue(Number(finalTotalsData.FixedTotal) +
+                Number(finalTotalsData.FixedInsTotal));
+            finalTotalsData.InsTotalRoundedBy = tr_utils_1.TrUtils.FixPriceValue(Math.round(Number(finalTotalsData.FixedInsTotal)) - Number(finalTotalsData.FixedInsTotal));
+            finalTotalsData.InsRoundedTotal = tr_utils_1.TrUtils.FixPriceValue(Math.round(Number(finalTotalsData.FixedInsTotal)));
+            let InsTaxGroupData = [];
+            finalTotalsData.InsTaxGroupData.forEach((InsTaxGroup) => {
+                let index = finalTotalsData.CustTaxGroupData.findIndex((CustTaxGroup) => {
+                    return CustTaxGroup.HSN === InsTaxGroup.HSN;
+                });
+                if (index !== -1) {
+                    InsTaxGroup.TotalTaxAmount = tr_utils_1.TrUtils.FixPriceValue(Number(InsTaxGroup.TotalTaxAmount) + Number(finalTotalsData.CustTaxGroupData[index].TotalTaxAmount));
+                    InsTaxGroup.TotalTaxableAmount = tr_utils_1.TrUtils.FixPriceValue(Number(InsTaxGroup.TotalTaxableAmount) + Number(finalTotalsData.CustTaxGroupData[index].TotalTaxableAmount));
+                }
+                InsTaxGroupData.push(InsTaxGroup);
+            });
+            finalTotalsData.InsTaxGroupData = InsTaxGroupData;
+        }
+        return finalTotalsData;
+    }
+    static GetDetailedInfoForItems(ROTotalsData) {
+        ROTotalsData.Ops = this.GetCustLaborPrintInfo(ROTotalsData.Ops);
+        ROTotalsData.Parts = this.GetCustItemsPrintInfo(ROTotalsData.Parts, ROTotalsData.Ops);
+        return ROTotalsData;
+    }
+    static GetCustLaborPrintInfo(LaborList) {
+        LaborList.forEach((Labor) => {
+            Labor.HSN = Labor.SAC;
+            if (Labor.Sts === enums_1.LaborStatusEnum.New || Labor.Sts === enums_1.LaborStatusEnum.WtngForAppr) {
+                Labor.UnPr = tr_utils_1.TrUtils.FixPriceValue(Labor.EstPr);
+                Labor.Disc = 0;
+                Labor.Perc = '';
+            }
+            else {
+                Labor.UnPr = tr_utils_1.TrUtils.FixPriceValue(Labor.Pr);
+            }
+        });
+        return LaborList;
+    }
+    static GetCustItemsPrintInfo(Items, LaborList) {
+        Items.forEach((Item) => {
+            let LaborStatus = tr_utils_1.TrUtils.IsNull(Item.CollId) ? this.GetPartParentStatus(Item.OpId, LaborList) : Item.Sts;
+            if (LaborStatus === enums_1.LaborStatusEnum.New || LaborStatus === enums_1.LaborStatusEnum.WtngForAppr) {
+                Item.UnPr = tr_utils_1.TrUtils.FixPriceValue(Item.EstPr);
+                Item.Disc = 0;
+                Item.Perc = '';
+            }
+            else {
+                Item.UnPr = tr_utils_1.TrUtils.FixPriceValue(Item.UnPr);
+            }
+        });
+        return Items;
+    }
+    static GetCustTaxInfo(ROTotalsData, IncludeGST, TaxCodes) {
+        ROTotalsData.Ops = this.GetCustLaborTaxInfo(ROTotalsData.Ops, IncludeGST, TaxCodes);
+        ROTotalsData.Parts = this.GetCustPartTaxInfo(ROTotalsData.Parts, ROTotalsData.Ops, IncludeGST, TaxCodes);
+        return ROTotalsData;
+    }
+    static GetCustLaborTaxInfo(LaborList, IncludeGST, TaxCodes) {
+        LaborList.forEach((Labor) => {
+            if (Labor.Sts === enums_1.LaborStatusEnum.New || Labor.Sts === enums_1.LaborStatusEnum.WtngForAppr) {
+                if (IncludeGST) {
+                    Labor.CGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Labor.ECGST);
+                    Labor.SGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Labor.ESGST);
+                    Labor.IGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Labor.EIGST);
+                }
+                else {
+                    Labor.CGSTAmt = 0;
+                    Labor.SGSTAmt = 0;
+                    Labor.IGSTAmt = 0;
+                }
+            }
+            else {
+                if (IncludeGST) {
+                    Labor.CGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Labor.CCGST);
+                    Labor.SGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Labor.CSGST);
+                    Labor.IGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Labor.CIGST);
+                }
+                else {
+                    Labor.CGSTAmt = 0;
+                    Labor.SGSTAmt = 0;
+                    Labor.IGSTAmt = 0;
+                }
+            }
+            Labor.CGSTPerc = shared_print_service_1.PrintSharedService.GetCGSTValueBasedOnTaxCode(Labor.TCode, TaxCodes);
+            Labor.SGSTPerc = shared_print_service_1.PrintSharedService.GetSGSTValueBasedOnTaxCode(Labor.TCode, TaxCodes);
+            Labor.IGSTPerc = shared_print_service_1.PrintSharedService.GetIGSTValueBasedOnTaxCode(Labor.TCode, TaxCodes);
+        });
+        return LaborList;
+    }
+    static GetCustPartTaxInfo(Items, LaborList, IncludeGST, TaxCodes) {
+        Items.forEach((Item) => {
+            let LaborStatus = tr_utils_1.TrUtils.IsNull(Item.CollId) ? this.GetPartParentStatus(Item.OpId, LaborList) : Item.Sts;
+            if (LaborStatus === enums_1.LaborStatusEnum.New || LaborStatus === enums_1.LaborStatusEnum.WtngForAppr) {
+                if (IncludeGST) {
+                    Item.CGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Item.ECGST);
+                    Item.SGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Item.ESGST);
+                    Item.IGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Item.EIGST);
+                }
+                else {
+                    Item.CGSTAmt = 0;
+                    Item.SGSTAmt = 0;
+                    Item.IGSTAmt = 0;
+                }
+            }
+            else {
+                if (IncludeGST) {
+                    Item.CGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Item.CCGST);
+                    Item.SGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Item.CSGST);
+                    Item.IGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Item.CIGST);
+                }
+                else {
+                    Item.CGSTAmt = 0;
+                    Item.SGSTAmt = 0;
+                    Item.IGSTAmt = 0;
+                }
+            }
+            Item.CGSTPerc = shared_print_service_1.PrintSharedService.GetCGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+            Item.SGSTPerc = shared_print_service_1.PrintSharedService.GetSGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+            Item.IGSTPerc = shared_print_service_1.PrintSharedService.GetIGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+        });
+        return Items;
+    }
+    static GetLaborAndPartItemsAfterDisc(ROTotalsData) {
+        ROTotalsData.Ops = this.GetCustLaborAfterDiscPrintInfo(ROTotalsData.Ops);
+        ROTotalsData.Parts = this.GetCustItemsAfterDiscPrintInfo(ROTotalsData.Parts, ROTotalsData.Ops);
+        return ROTotalsData;
+    }
+    static GetCustLaborAfterDiscPrintInfo(LaborList) {
+        LaborList.forEach((Labor) => {
+            Labor.HSN = Labor.SAC;
+            if (Labor.Sts === enums_1.LaborStatusEnum.New || Labor.Sts === enums_1.LaborStatusEnum.WtngForAppr) {
+                Labor.UnPr = tr_utils_1.TrUtils.FixPriceValue(Labor.EstPr);
+            }
+            else {
+                Labor.UnPr = tr_utils_1.TrUtils.FixPriceValue(Labor.NetAmt);
+            }
+        });
+        return LaborList;
+    }
+    static GetCustItemsAfterDiscPrintInfo(Items, LaborList) {
+        Items.forEach((Item) => {
+            let LaborStatus = tr_utils_1.TrUtils.IsNull(Item.CollId) ? this.GetPartParentStatus(Item.OpId, LaborList) : Item.Sts;
+            if (LaborStatus === enums_1.LaborStatusEnum.New || LaborStatus === enums_1.LaborStatusEnum.WtngForAppr) {
+                Item.UnPr = tr_utils_1.TrUtils.FixPriceValue(Item.EstPr);
+            }
+            else {
+                Item.UnPr = tr_utils_1.TrUtils.FixedTo((0, aggregation_1.division)(Item.NetAmt, Item.Qty));
+            }
+        });
+        return Items;
+    }
+    static GetPartParentStatus(PartOpId, LaborList) {
+        let index = LaborList.findIndex((Labor) => {
+            return Labor._id === PartOpId;
+        });
+        return LaborList[index].Sts;
+    }
+    static GetCombinedInfoForItems(ROTotalsData) {
+        ROTotalsData.Ops = this.GetLaborCombinedPrintInfo(ROTotalsData.Ops);
+        ROTotalsData.Parts = this.GetItemsCombinedPrintInfo(ROTotalsData.Parts);
+        return ROTotalsData;
+    }
+    static GetLaborCombinedPrintInfo(LaborList) {
+        LaborList.forEach((Labor) => {
+            Labor.AssPr = tr_utils_1.TrUtils.FixedTo((0, aggregation_1.addition)(Labor.AssPr, Labor.NetAmt));
+        });
+        return LaborList;
+    }
+    static GetItemsCombinedPrintInfo(Items) {
+        Items.forEach((Item) => {
+            Item.AssPr = tr_utils_1.TrUtils.FixedTo((0, aggregation_1.division)((0, aggregation_1.addition)(Item.AssAmt, Item.NetAmt), Item.Qty));
+        });
+        return Items;
+    }
+    static GetSplitInfoForParts(Items) {
+        Items.forEach((Item) => {
+            Item.UnPr = tr_utils_1.TrUtils.FixedTo((0, aggregation_1.division)(Item.NetAmt, Item.Qty));
+        });
+        return Items;
+    }
+    static CheckLaborTaxItemIndex(LaborList) {
+        let TaxIndex = LaborList.findIndex((Labor) => {
+            if (!tr_utils_1.TrUtils.CheckInvalidSelect(Labor.TCode)) {
+                return Labor;
+            }
+        });
+        return TaxIndex;
+    }
+    static CheckPartTaxItemIndex(PartsList) {
+        let TaxIndex = PartsList.findIndex((Part) => {
+            if (!tr_utils_1.TrUtils.CheckInvalidSelect(Part.TCode)) {
+                return Part;
+            }
+        });
+        return TaxIndex;
+    }
+    static PrepareFormatForEstPrint(ROPrintData, SuppEstCodeValue, OverAllEst, argROType, AsEstimated) {
+        let PrintInfo = [];
+        if (OverAllEst === true) {
+            let ROLaborParts = this.GetFormatForEstPrint(null, null, ROPrintData, argROType, AsEstimated);
+            PrintInfo.push(ROLaborParts);
+            ROPrintData.SuppEst.forEach((SuppEstCode, index) => {
+                let ROPrintInfo = this.GetFormatForEstPrint(SuppEstCode.Id, index, ROPrintData, argROType, AsEstimated);
+                PrintInfo.push(ROPrintInfo);
+            });
+        }
+        else {
+            let SuppEstIndex;
+            if (!tr_utils_1.TrUtils.IsNull(SuppEstCodeValue)) {
+                SuppEstIndex = ROPrintData.SuppEst.findIndex((SuppEst) => {
+                    return SuppEst.Id === SuppEstCodeValue;
+                });
+                if (SuppEstIndex === -1) {
+                    SuppEstIndex = null;
+                }
+            }
+            let ROLaborParts = this.GetFormatForEstPrint(SuppEstCodeValue, SuppEstIndex, ROPrintData, argROType, AsEstimated);
+            PrintInfo.push(ROLaborParts);
+        }
+        return PrintInfo;
+    }
+    static GetFormatForEstPrint(SuppEstCodeValue, SuppEstIndex, ROPrintData, argROType, AsEstimated) {
+        let ROLaborParts = {};
+        if (!tr_utils_1.TrUtils.IsNull(SuppEstIndex)) {
+            ROLaborParts.Text = 'Supp.Est -' + (SuppEstIndex + 1);
+        }
+        ROLaborParts.Ops = this.SeparateLaborListByPTypeAndSuppIndex(ROPrintData.Ops, SuppEstCodeValue);
+        ROLaborParts.Parts = this.SeparateOnlyPartsByPTypeAndSuppIndex(ROPrintData.Parts, SuppEstCodeValue);
+        ROLaborParts.Colli = this.SeparateCollisionBySuppIndex(ROPrintData.Colli, SuppEstCodeValue);
+        if (AsEstimated) {
+            ROLaborParts.Sts = enums_1.EstimateStatusEnum.New;
+        }
+        else {
+            ROLaborParts.Sts = enums_1.EstimateStatusEnum.Approved;
+        }
+        ROLaborParts.Type = argROType;
+        return ROLaborParts;
+    }
+    static SeparateLaborListByPTypeAndSuppIndex(Operations, SuppEstCodeValue) {
+        let Ops = [];
+        Ops = Operations.filter((Operation) => {
+            if (tr_utils_1.TrUtils.IsNull(Operation.SuppEst)) {
+                Operation.SuppEst = null;
+            }
+            return Operation.SuppEst === SuppEstCodeValue;
+        });
+        return Ops;
+    }
+    static SeparateOnlyPartsByPTypeAndSuppIndex(Parts, SuppEstCodeValue) {
+        let SParts = [];
+        SParts = Parts.filter((Part) => {
+            if (tr_utils_1.TrUtils.IsNull(Part.SuppEst)) {
+                Part.SuppEst = null;
+            }
+            return Part.SuppEst === SuppEstCodeValue;
+        });
+        return SParts;
+    }
+    static SeparateCollisionBySuppIndex(Collisions, SuppEstCodeValue) {
+        let FilteredCollisions = [];
+        FilteredCollisions = Collisions.filter((Collision) => {
+            if (tr_utils_1.TrUtils.IsNull(Collision.SuppEst)) {
+                Collision.SuppEst = null;
+            }
+            if (Collision.SuppEst === SuppEstCodeValue) {
+                return Collision;
+            }
+        });
+        return FilteredCollisions;
+    }
+    static CheckAndCombineDescMPNForAR(PrintPartNo, ROPrintData) {
+        if (PrintPartNo) {
+            ROPrintData.PrintInfo.forEach((PrintData) => {
+                PrintData.Colli.forEach((Collision) => {
+                    if (!tr_utils_1.TrUtils.IsNull(Collision.PartData) && !tr_utils_1.TrUtils.IsEmpty(Collision.PartData.MPN)) {
+                        Collision.Desc = Collision.Desc + '/' + Collision.PartData.MPN;
+                    }
+                });
+            });
+        }
+        return ROPrintData;
+    }
+}
+exports.EstPrintService = EstPrintService;