shareneus 1.0.5

package/dist/services/ro-totals.service.js

@@ -0,0 +1,1241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROTotalsService = void 0;
+const aggregation_1 = require("../aggregation/aggregation");
+const enums_1 = require("../enums/enums");
+const tr_utils_1 = require("../utils/tr-utils");
+class ROTotalsService {
+    static GetTotalsValue(OriRecordData, TaxCodes, isWorkOrder, detailedInfo, withItems, isRoundable) {
+        let dupRecordData = tr_utils_1.TrUtils.Stringify(OriRecordData);
+        let argRecordData = {};
+        dupRecordData.Ops = this.CalculateLaborValues(dupRecordData.Ops, isWorkOrder, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        dupRecordData.Parts = this.CalculatePartValues(dupRecordData.Parts, dupRecordData.Ops, isWorkOrder, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        argRecordData = this.GetROTotalsData(argRecordData, dupRecordData, TaxCodes, withItems, detailedInfo, isWorkOrder, isRoundable);
+        return argRecordData;
+    }
+    static CalculateLaborValues(opCodesList, isWorkOrder, isTaxable) {
+        opCodesList = this.FilterValidLaborItems(opCodesList);
+        opCodesList = this.ResetLaborValuesIfInvalid(opCodesList, isWorkOrder);
+        opCodesList = this.GetOperationsDiscountPrice(opCodesList, isWorkOrder);
+        opCodesList = this.GetOperationsAfterDiscount(opCodesList, isWorkOrder);
+        opCodesList = this.GetOperationsAfterTax(opCodesList, isWorkOrder, isTaxable);
+        return opCodesList;
+    }
+    static FilterValidLaborItems(opCodesList) {
+        opCodesList = opCodesList.filter((Labor) => {
+            return Labor.Sts !== enums_1.LaborStatusEnum.Cancelled && Labor.Sts !== enums_1.LaborStatusEnum.Declined;
+        });
+        return opCodesList;
+    }
+    static ResetLaborValuesIfInvalid(opCodesList, isWorkOrder) {
+        opCodesList.forEach((Operation) => {
+            Operation = this.ResetLaborValueIfInvalid(Operation, isWorkOrder);
+        });
+        return opCodesList;
+    }
+    static ResetLaborValueIfInvalid(Operation, isWorkOrder) {
+        Operation.Perc = tr_utils_1.TrUtils.SetPercToStringIfNull(Operation.Perc);
+        Operation.Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.Disc);
+        Operation.Pr = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.Pr);
+        Operation.AssPr = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.AssPr);
+        Operation.ACGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.ACGST);
+        Operation.ASGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.ASGST);
+        Operation.AIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.AIGST);
+        Operation.CCGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.CCGST);
+        Operation.CSGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.CSGST);
+        Operation.CIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.CIGST);
+        Operation.NetAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.NetAmt);
+        Operation.RecDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.RecDisc);
+        if (!isWorkOrder) {
+            Operation.EstPr = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.EstPr);
+            Operation.ECGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.ECGST);
+            Operation.ESGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.ESGST);
+            Operation.EIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.EIGST);
+        }
+        return Operation;
+    }
+    static GetOperationsDiscountPrice(OperationsList, isWorkOrder) {
+        OperationsList.forEach((Operation) => {
+            if (isWorkOrder) {
+                Operation.CustDiscountedPrice = (0, aggregation_1.addition)(Operation.Disc, Operation.RecDisc);
+            }
+            else {
+                if (Operation.Sts === enums_1.LaborStatusEnum.New || Operation.Sts === enums_1.LaborStatusEnum.WtngForAppr) {
+                    Operation.CustDiscountedPrice = 0;
+                }
+                else {
+                    Operation.CustDiscountedPrice = (0, aggregation_1.addition)(Operation.Disc, Operation.RecDisc);
+                }
+            }
+        });
+        return OperationsList;
+    }
+    static GetOperationsAfterDiscount(OperationsList, isWorkOrder) {
+        OperationsList.forEach((Operation) => {
+            let CustAfterLaborDisc = 0;
+            let InsAfterLaborDisc = 0;
+            if (Operation.PBy === enums_1.PayTypeEnum.Customer) {
+                if (isWorkOrder) {
+                    CustAfterLaborDisc = Operation.NetAmt;
+                }
+                else {
+                    if (Operation.Sts === enums_1.LaborStatusEnum.New || Operation.Sts === enums_1.LaborStatusEnum.WtngForAppr) {
+                        CustAfterLaborDisc = Operation.EstPr;
+                    }
+                    else {
+                        CustAfterLaborDisc = Operation.NetAmt;
+                    }
+                }
+            }
+            else {
+                if (isWorkOrder) {
+                    CustAfterLaborDisc = Operation.NetAmt;
+                    InsAfterLaborDisc = Operation.AssPr;
+                }
+                else {
+                    if (Operation.Sts === enums_1.LaborStatusEnum.New || Operation.Sts === enums_1.LaborStatusEnum.WtngForAppr) {
+                        InsAfterLaborDisc = Operation.EstPr;
+                    }
+                    else {
+                        CustAfterLaborDisc = Operation.NetAmt;
+                        InsAfterLaborDisc = Operation.AssPr;
+                    }
+                }
+            }
+            Operation.CustAfterLaborDisc = CustAfterLaborDisc;
+            Operation.InsAfterLaborDisc = InsAfterLaborDisc;
+        });
+        return OperationsList;
+    }
+    static GetOperationsAfterTax(OperationsList, isWorkOrder, isTaxable) {
+        OperationsList.forEach((Operation) => {
+            if (!isTaxable) {
+                Operation.CustAfterTax = Operation.CustAfterLaborDisc;
+                Operation.InsAfterTax = Operation.InsAfterLaborDisc;
+            }
+            else {
+                if (Operation.PBy === enums_1.PayTypeEnum.Customer) {
+                    if (isWorkOrder) {
+                        Operation.CustAfterTax = (0, aggregation_1.addition)(Operation.CustAfterLaborDisc, Operation.CCGST, Operation.CSGST, Operation.CIGST);
+                    }
+                    else {
+                        if (Operation.Sts !== enums_1.LaborStatusEnum.New && Operation.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                            Operation.CustAfterTax = (0, aggregation_1.addition)(Operation.CustAfterLaborDisc, Operation.CCGST, Operation.CSGST, Operation.CIGST);
+                        }
+                        else {
+                            Operation.CustAfterTax = (0, aggregation_1.addition)(Operation.CustAfterLaborDisc, Operation.ECGST, Operation.ESGST, Operation.EIGST);
+                        }
+                    }
+                    Operation.InsAfterTax = 0;
+                }
+                else {
+                    if (isWorkOrder) {
+                        Operation.CustAfterTax = (0, aggregation_1.addition)(Operation.CustAfterLaborDisc, Operation.CCGST, Operation.CSGST, Operation.CIGST);
+                        Operation.InsAfterTax = (0, aggregation_1.addition)(Operation.InsAfterLaborDisc, Operation.ACGST, Operation.ASGST, Operation.AIGST);
+                    }
+                    else {
+                        if (Operation.Sts !== enums_1.LaborStatusEnum.New && Operation.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                            Operation.CustAfterTax = (0, aggregation_1.addition)(Operation.CustAfterLaborDisc, Operation.CCGST, Operation.CSGST, Operation.CIGST);
+                            Operation.InsAfterTax = (0, aggregation_1.addition)(Operation.InsAfterLaborDisc, Operation.ACGST, Operation.ASGST, Operation.AIGST);
+                        }
+                        else {
+                            Operation.CustAfterTax = 0;
+                            Operation.InsAfterTax = (0, aggregation_1.addition)(Operation.InsAfterLaborDisc, Operation.ECGST, Operation.ESGST, Operation.EIGST);
+                        }
+                    }
+                }
+            }
+        });
+        return OperationsList;
+    }
+    static CalculatePartValues(PartsList, LaborList, isWorkOrder, isTaxable) {
+        PartsList = this.FilterValidPartItems(PartsList);
+        PartsList = this.ResetPartValuesIfInvalid(PartsList, isWorkOrder);
+        PartsList = this.GetPartsDiscountPrice(PartsList, LaborList, isWorkOrder);
+        PartsList = this.GetPartsAfterDiscount(PartsList, LaborList, isWorkOrder);
+        PartsList = this.GetPartsAfterTax(PartsList, LaborList, isWorkOrder, isTaxable);
+        PartsList = this.GetPartsPerItemAfterTax(PartsList);
+        return PartsList;
+    }
+    static FilterValidPartItems(PartsList) {
+        PartsList = PartsList.filter((Part) => {
+            if (tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                return Part;
+            }
+            else {
+                return Part.Sts !== enums_1.LaborStatusEnum.Cancelled && Part.Sts !== enums_1.LaborStatusEnum.Declined;
+            }
+        });
+        return PartsList;
+    }
+    static ResetPartValuesIfInvalid(PartsList, isWorkOrder) {
+        PartsList.forEach((Part) => {
+            Part = this.ResetPartValueIfInvalid(Part, isWorkOrder);
+        });
+        return PartsList;
+    }
+    static ResetPartValueIfInvalid(Part, isWorkOrder) {
+        Part.Perc = tr_utils_1.TrUtils.SetPercToStringIfNull(Part.Perc);
+        Part.Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.Disc);
+        Part.UnPr = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.UnPr);
+        Part.AssPr = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.AssPr);
+        Part.ACGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.ACGST);
+        Part.ASGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.ASGST);
+        Part.AIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.AIGST);
+        Part.CCGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.CCGST);
+        Part.CSGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.CSGST);
+        Part.CIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.CIGST);
+        Part.UnAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.UnAmt);
+        Part.AssAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.AssAmt);
+        Part.NetAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.NetAmt);
+        Part.RecDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.RecDisc);
+        if (!isWorkOrder) {
+            Part.EstPr = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.EstPr);
+            Part.ECGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.ECGST);
+            Part.ESGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.ESGST);
+            Part.EIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.EIGST);
+            Part.EstAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.EstAmt);
+        }
+        return Part;
+    }
+    static GetPartsDiscountPrice(PartsList, LaborList, isWorkOrder) {
+        PartsList.forEach((Part) => {
+            if (tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                if (isWorkOrder) {
+                    Part.CustDiscountedPrice = (0, aggregation_1.addition)(Part.Disc, Part.RecDisc);
+                }
+                else {
+                    let LaborSts = this.GetPartParentStatus(Part, LaborList);
+                    if (LaborSts === enums_1.LaborStatusEnum.New || LaborSts === enums_1.LaborStatusEnum.WtngForAppr) {
+                        Part.CustDiscountedPrice = 0;
+                    }
+                    else {
+                        Part.CustDiscountedPrice = (0, aggregation_1.addition)(Part.Disc, Part.RecDisc);
+                    }
+                }
+            }
+            else {
+                if (isWorkOrder) {
+                    Part.CustDiscountedPrice = (0, aggregation_1.addition)(Part.Disc, Part.RecDisc);
+                }
+                else {
+                    if (Part.Sts === enums_1.LaborStatusEnum.New || Part.Sts === enums_1.LaborStatusEnum.WtngForAppr) {
+                        Part.CustDiscountedPrice = 0;
+                    }
+                    else {
+                        Part.CustDiscountedPrice = (0, aggregation_1.addition)(Part.Disc, Part.RecDisc);
+                    }
+                }
+            }
+        });
+        return PartsList;
+    }
+    static GetPartParentStatus(Part, LaborList) {
+        if (!tr_utils_1.TrUtils.IsNull(Part.OpId)) {
+            let index = LaborList.findIndex((Labor) => {
+                return Labor._id === Part.OpId;
+            });
+            return LaborList[index].Sts;
+        }
+        else {
+            return Part.Sts;
+        }
+    }
+    static GetPartsAfterDiscount(PartsList, LaborList, isWorkOrder) {
+        PartsList.forEach((Part) => {
+            if (tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                let CustAfterPartDisc = 0;
+                let InsAfterPartDisc = 0;
+                if (isWorkOrder) {
+                    CustAfterPartDisc = Part.NetAmt;
+                    if (tr_utils_1.TrUtils.IsNull(Part.OpId)) {
+                        InsAfterPartDisc = Part.AssAmt;
+                    }
+                }
+                else {
+                    let LaborSts = this.GetPartParentStatus(Part, LaborList);
+                    if (LaborSts === enums_1.LaborStatusEnum.New || LaborSts === enums_1.LaborStatusEnum.WtngForAppr) {
+                        CustAfterPartDisc = Part.EstAmt;
+                    }
+                    else {
+                        CustAfterPartDisc = Part.NetAmt;
+                        if (tr_utils_1.TrUtils.IsNull(Part.OpId)) {
+                            InsAfterPartDisc = Part.AssAmt;
+                        }
+                    }
+                }
+                Part.CustAfterPartDisc = CustAfterPartDisc;
+                Part.InsAfterPartDisc = InsAfterPartDisc;
+            }
+            else {
+                let CustAfterPartDisc = 0;
+                let InsAfterPartDisc = 0;
+                if (Part.PBy === enums_1.PayTypeEnum.Customer) {
+                    if (isWorkOrder) {
+                        CustAfterPartDisc = Part.NetAmt;
+                    }
+                    else {
+                        if (Part.Sts === enums_1.LaborStatusEnum.New || Part.Sts === enums_1.LaborStatusEnum.WtngForAppr) {
+                            CustAfterPartDisc = Part.EstAmt;
+                        }
+                        else {
+                            CustAfterPartDisc = Part.NetAmt;
+                        }
+                    }
+                }
+                else {
+                    if (isWorkOrder) {
+                        CustAfterPartDisc = Part.NetAmt;
+                        InsAfterPartDisc = Part.AssAmt;
+                    }
+                    else {
+                        if (Part.Sts === enums_1.LaborStatusEnum.New || Part.Sts === enums_1.LaborStatusEnum.WtngForAppr) {
+                            InsAfterPartDisc = Part.EstAmt;
+                        }
+                        else {
+                            CustAfterPartDisc = Part.NetAmt;
+                            InsAfterPartDisc = Part.AssAmt;
+                        }
+                    }
+                }
+                Part.CustAfterPartDisc = CustAfterPartDisc;
+                Part.InsAfterPartDisc = InsAfterPartDisc;
+            }
+        });
+        return PartsList;
+    }
+    static GetPartsAfterTax(PartsList, LaborList, isWorkOrder, isTaxable) {
+        PartsList.forEach((Part) => {
+            if (!isTaxable) {
+                Part.CustAfterTax = Part.CustAfterPartDisc;
+                Part.InsAfterTax = Part.InsAfterPartDisc;
+            }
+            else {
+                if (tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                    if (isWorkOrder) {
+                        Part.CustAfterTax = (0, aggregation_1.addition)(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
+                        if (tr_utils_1.TrUtils.IsNull(Part.OpId)) {
+                            Part.InsAfterTax = (0, aggregation_1.addition)(Part.InsAfterPartDisc, Part.ACGST, Part.ASGST, Part.AIGST);
+                        }
+                    }
+                    else {
+                        let LaborSts = this.GetPartParentStatus(Part, LaborList);
+                        if (LaborSts === enums_1.LaborStatusEnum.New || LaborSts === enums_1.LaborStatusEnum.WtngForAppr) {
+                            Part.CustAfterTax = (0, aggregation_1.addition)(Part.CustAfterPartDisc, Part.ECGST, Part.ESGST, Part.EIGST);
+                        }
+                        else {
+                            Part.CustAfterTax = (0, aggregation_1.addition)(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
+                            if (tr_utils_1.TrUtils.IsNull(Part.OpId)) {
+                                Part.InsAfterTax = (0, aggregation_1.addition)(Part.InsAfterPartDisc, Part.ACGST, Part.ASGST, Part.AIGST);
+                            }
+                        }
+                    }
+                    // Part.InsAfterTax = 0;
+                }
+                else {
+                    if (Part.PBy === enums_1.PayTypeEnum.Customer) {
+                        if (isWorkOrder) {
+                            Part.CustAfterTax = (0, aggregation_1.addition)(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
+                        }
+                        else {
+                            if (Part.Sts !== enums_1.LaborStatusEnum.New && Part.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                                Part.CustAfterTax = (0, aggregation_1.addition)(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
+                            }
+                            else {
+                                Part.CustAfterTax = (0, aggregation_1.addition)(Part.CustAfterPartDisc, Part.ECGST, Part.ESGST, Part.EIGST);
+                            }
+                        }
+                        Part.InsAfterTax = 0;
+                    }
+                    else {
+                        if (isWorkOrder) {
+                            Part.CustAfterTax = (0, aggregation_1.addition)(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
+                            Part.InsAfterTax = (0, aggregation_1.addition)(Part.InsAfterPartDisc, Part.ACGST, Part.ASGST, Part.AIGST);
+                        }
+                        else {
+                            if (Part.Sts !== enums_1.LaborStatusEnum.New && Part.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                                Part.CustAfterTax = (0, aggregation_1.addition)(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
+                                Part.InsAfterTax = (0, aggregation_1.addition)(Part.InsAfterPartDisc, Part.ACGST, Part.ASGST, Part.AIGST);
+                            }
+                            else {
+                                Part.CustAfterTax = 0;
+                                Part.InsAfterTax = (0, aggregation_1.addition)(Part.InsAfterPartDisc, Part.ECGST, Part.ESGST, Part.EIGST);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        return PartsList;
+    }
+    static GetPartsPerItemAfterTax(PartsList) {
+        PartsList.forEach((Part) => {
+            Part.CustAfterTaxPerItem = (0, aggregation_1.division)(Part.CustAfterTax, Part.Qty);
+            Part.InsAfterTaxPerItem = (0, aggregation_1.division)(Part.InsAfterTax, Part.Qty);
+        });
+        return PartsList;
+    }
+    static GetROTotalsData(argRecordData, dupRecordData, TaxCodes, withItems, detailedInfo, isWorkOrder, isRoundable) {
+        dupRecordData = this.ResetDiscountValuesIfInvalid(dupRecordData);
+        argRecordData = this.SetMainDiscountValues(argRecordData, dupRecordData, detailedInfo);
+        argRecordData = this.GetFinalCustomerTotalsData(argRecordData, dupRecordData, isWorkOrder, detailedInfo, isRoundable);
+        argRecordData = this.GetFinalInsuranceTotalsData(argRecordData, dupRecordData, detailedInfo, isWorkOrder);
+        if (detailedInfo) {
+            argRecordData = this.GetDetailedTotalsData(argRecordData, dupRecordData, TaxCodes, isWorkOrder);
+        }
+        if (withItems) {
+            argRecordData.Ops = dupRecordData.Ops;
+            argRecordData.Parts = dupRecordData.Parts;
+            argRecordData.Colli = dupRecordData.Colli;
+        }
+        return argRecordData;
+    }
+    static ResetDiscountValuesIfInvalid(dupRecordData) {
+        dupRecordData.LPerc = tr_utils_1.TrUtils.SetPercToStringIfNull(dupRecordData.LPerc);
+        dupRecordData.PPerc = tr_utils_1.TrUtils.SetPercToStringIfNull(dupRecordData.PPerc);
+        dupRecordData.Perc = tr_utils_1.TrUtils.SetPercToStringIfNull(dupRecordData.Perc);
+        dupRecordData.LDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(dupRecordData.LDisc);
+        dupRecordData.PDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(dupRecordData.PDisc);
+        dupRecordData.Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(dupRecordData.Disc);
+        return dupRecordData;
+    }
+    static SetMainDiscountValues(argRecordData, dupRecordData, detailedInfo) {
+        argRecordData.LDisc = dupRecordData.LDisc;
+        argRecordData.LPerc = dupRecordData.LPerc;
+        argRecordData.PDisc = dupRecordData.PDisc;
+        argRecordData.PPerc = dupRecordData.PPerc;
+        argRecordData.Disc = dupRecordData.Disc;
+        argRecordData.Perc = dupRecordData.Perc;
+        if (detailedInfo) {
+            argRecordData.FixedLDisc = dupRecordData.LDisc;
+            argRecordData.FixedPDisc = dupRecordData.PDisc;
+            argRecordData.FixedDisc = dupRecordData.Disc;
+        }
+        return argRecordData;
+    }
+    static GetFinalCustomerTotalsData(argRecordData, dupRecordData, isWorkOrder, detailedInfo, isRoundable) {
+        let CustomerAfterDiscTotals = this.GetCustSubTotal(dupRecordData.Ops, dupRecordData.Parts);
+        let CustLaborTaxTotal = this.GetCustLaborTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        let CustPartTaxTotal = this.GetCustPartsTaxTotal(dupRecordData.Ops, dupRecordData.Parts, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        let CustLaborDiscTotal = this.GetCustLaborDiscountedTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);
+        let CustPartsDiscTotal = this.GetCustPartDiscountedTotal(dupRecordData.Parts, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);
+        let CustLaborTotalAfterDisc = this.GetCustLaborTotalAfterDiscount(dupRecordData.Ops);
+        let CustPartsTotalAfterDisc = this.GetCustPartsTotalAfterDiscount(dupRecordData.Parts);
+        argRecordData.STotal = (0, aggregation_1.addition)(CustLaborDiscTotal, CustPartsDiscTotal, CustLaborTotalAfterDisc, CustPartsTotalAfterDisc);
+        argRecordData.CustLaborTotalBeforeDisc = (0, aggregation_1.addition)(argRecordData.CustLaborTotalAfterDisc, argRecordData.CustLaborDiscTotal);
+        argRecordData.CustPartsTotalBeforeDisc = (0, aggregation_1.addition)(argRecordData.CustPartsTotalAfterDisc, argRecordData.CustPartsDiscTotal);
+        argRecordData.SubTotal = tr_utils_1.TrUtils.FixedTo(CustomerAfterDiscTotals);
+        let CustTotal = this.GetCustomerTotalBasedOnTaxType(dupRecordData, CustLaborTaxTotal, CustPartTaxTotal, dupRecordData.Ops, dupRecordData.Parts, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        if (detailedInfo) {
+            argRecordData.FixedSubTotal = tr_utils_1.TrUtils.FixedTo(CustomerAfterDiscTotals);
+            argRecordData.FixedTotal = tr_utils_1.TrUtils.FixedTo(CustTotal);
+        }
+        if (isRoundable) {
+            argRecordData.Round = (0, aggregation_1.subtraction)(Math.round(CustTotal), CustTotal);
+            argRecordData.Total = Math.round(CustTotal);
+        }
+        else {
+            argRecordData.Total = tr_utils_1.TrUtils.FixedTo(CustTotal);
+        }
+        return argRecordData;
+    }
+    static GetCustSubTotal(LaborList, PartsList) {
+        let LaborTotalAfterDisc = this.GetCustLaborTotalAfterDiscount(LaborList);
+        let PartsTotalAfterDisc = this.GetCustPartsTotalAfterDiscount(PartsList);
+        return (0, aggregation_1.addition)(LaborTotalAfterDisc, PartsTotalAfterDisc);
+    }
+    static GetCustLaborTotalAfterDiscount(LaborList) {
+        let LaborTotalAfterDisc = 0;
+        LaborList.forEach((Labor) => {
+            LaborTotalAfterDisc = (0, aggregation_1.addition)(LaborTotalAfterDisc, Labor.CustAfterLaborDisc);
+        });
+        return LaborTotalAfterDisc;
+    }
+    static GetCustPartsTotalAfterDiscount(PartsList) {
+        let PartsTotalAfterDisc = 0;
+        PartsList.forEach((Part) => {
+            PartsTotalAfterDisc = (0, aggregation_1.addition)(PartsTotalAfterDisc, Part.CustAfterPartDisc);
+        });
+        return PartsTotalAfterDisc;
+    }
+    static GetCustLaborTaxTotal(opCodesList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor) => {
+                if (isWorkOrder) {
+                    // if (Labor.PBy === PayTypeEnum.Customer) {
+                    if ((Labor.PBy === enums_1.PayTypeEnum.Customer || Labor.PBy === enums_1.PayTypeEnum.Shared)) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.CCGST, Labor.CSGST, Labor.CIGST);
+                    }
+                    // }else{
+                    //     TotalTaxAmt = addition(TotalTaxAmt , Labor.ACGST , Labor.ASGST , Labor.AIGST);
+                    // }
+                }
+                else {
+                    if (Labor.Sts !== enums_1.LaborStatusEnum.New && Labor.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.CCGST, Labor.CSGST, Labor.CIGST);
+                    }
+                    else {
+                        if (Labor.PBy === enums_1.PayTypeEnum.Customer) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.ECGST, Labor.ESGST, Labor.EIGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetCustPartsTaxTotal(OpsList, PartsList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part) => {
+                if (!tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                    if (isWorkOrder) {
+                        if ((Part.PBy === enums_1.PayTypeEnum.Customer || Part.PBy === enums_1.PayTypeEnum.Shared)) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
+                        }
+                    }
+                    else {
+                        if (Part.Sts !== enums_1.LaborStatusEnum.New && Part.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
+                        }
+                        else {
+                            if (Part.PBy === enums_1.PayTypeEnum.Customer) {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ECGST, Part.ESGST, Part.EIGST);
+                            }
+                        }
+                    }
+                }
+                else {
+                    if (isWorkOrder) {
+                        // if (Part.PBy === PayTypeEnum.Customer) {
+                        if ((Part.PBy === enums_1.PayTypeEnum.Customer || Part.PBy === enums_1.PayTypeEnum.Shared)) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
+                        }
+                        // }else{
+                        //         TotalTaxAmt = addition(TotalTaxAmt , Part.ACGST , Part.ASGST , Part.AIGST);
+                        //     }
+                    }
+                    else {
+                        let Index = OpsList.findIndex((labor) => {
+                            return labor._id === Part.OpId;
+                        });
+                        if (Index !== -1) {
+                            if (OpsList[Index].Sts !== enums_1.LaborStatusEnum.New && OpsList[Index].Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
+                            }
+                            else {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ECGST, Part.ESGST, Part.EIGST);
+                            }
+                        }
+                        else {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetCustomerTotalBasedOnTaxType(dupRecordData, LaborTaxAmount, PartsTaxAmount, LaborList, PartsList, IsTaxable) {
+        let SubTotalWithTax = 0;
+        let LaborTotalAfterDisc = this.GetCustLaborTotalAfterDiscount(LaborList);
+        let PartsTotalAfterDisc = this.GetCustPartsTotalAfterDiscount(PartsList);
+        if (IsTaxable) {
+            SubTotalWithTax = (0, aggregation_1.addition)(LaborTotalAfterDisc, PartsTotalAfterDisc, LaborTaxAmount, PartsTaxAmount);
+        }
+        else {
+            SubTotalWithTax = (0, aggregation_1.addition)((0, aggregation_1.subtraction)(LaborTotalAfterDisc, dupRecordData.LDisc), (0, aggregation_1.subtraction)((0, aggregation_1.subtraction)(PartsTotalAfterDisc, dupRecordData.PDisc), dupRecordData.Disc));
+        }
+        return SubTotalWithTax;
+    }
+    static GetFinalInsuranceTotalsData(argRecordData, dupRecordData, detailedInfo, isWorkOrder) {
+        let InsuranceAfterDiscTotals = this.GetInsSubTotal(dupRecordData.Ops, dupRecordData.Parts);
+        let InsLaborTaxTotal = this.GetInsLaborTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        let InsPartTaxTotal = this.GetInsPartsTaxTotal(dupRecordData.Parts, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        let InsTotal = this.GetInsuranceTotalBasedOnTaxType(InsuranceAfterDiscTotals, InsLaborTaxTotal, InsPartTaxTotal, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        argRecordData.InsTotal = tr_utils_1.TrUtils.FixedTo(InsTotal);
+        if (detailedInfo) {
+            argRecordData.FixedInsTotal = tr_utils_1.TrUtils.FixedTo(InsTotal);
+        }
+        return argRecordData;
+    }
+    static GetInsSubTotal(LaborList, PartsList) {
+        let LaborTotalAfterDisc = this.GetInsLaborTotalAfterDiscount(LaborList);
+        let PartsTotalAfterDisc = this.GetInsPartsTotalAfterDiscount(PartsList);
+        return (0, aggregation_1.addition)(LaborTotalAfterDisc, PartsTotalAfterDisc);
+    }
+    static GetInsLaborTotalAfterDiscount(LaborList) {
+        let LaborTotalAfterDisc = 0;
+        LaborList.forEach((Labor) => {
+            LaborTotalAfterDisc = (0, aggregation_1.addition)(LaborTotalAfterDisc, Labor.InsAfterLaborDisc);
+        });
+        return LaborTotalAfterDisc;
+    }
+    static GetInsPartsTotalAfterDiscount(PartsList) {
+        let PartsTotalAfterDisc = 0;
+        PartsList.forEach((Part) => {
+            PartsTotalAfterDisc = (0, aggregation_1.addition)(PartsTotalAfterDisc, Part.InsAfterPartDisc);
+        });
+        return PartsTotalAfterDisc;
+    }
+    static GetInsLaborTaxTotal(opCodesList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor) => {
+                if (isWorkOrder) {
+                    if ((Labor.PBy === enums_1.PayTypeEnum.Insurance || Labor.PBy === enums_1.PayTypeEnum.Shared)) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.ACGST, Labor.ASGST, Labor.AIGST);
+                    }
+                }
+                else {
+                    if (Labor.Sts !== enums_1.LaborStatusEnum.New && Labor.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.ACGST, Labor.ASGST, Labor.AIGST);
+                    }
+                    else {
+                        if (Labor.PBy === enums_1.PayTypeEnum.Insurance || Labor.PBy === enums_1.PayTypeEnum.Shared) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.ECGST, Labor.ESGST, Labor.EIGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetInsPartsTaxTotal(PartsList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part) => {
+                if (!tr_utils_1.TrUtils.IsNull(Part.CollId) || Part.PBy === enums_1.PayTypeEnum.Insurance || Part.PBy === enums_1.PayTypeEnum.Shared) {
+                    if (isWorkOrder) {
+                        if ((Part.PBy === enums_1.PayTypeEnum.Insurance || Part.PBy === enums_1.PayTypeEnum.Shared)) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ACGST, Part.ASGST, Part.AIGST);
+                        }
+                    }
+                    else {
+                        if (Part.Sts !== enums_1.LaborStatusEnum.New && Part.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ACGST, Part.ASGST, Part.AIGST);
+                        }
+                        else {
+                            if (Part.PBy === enums_1.PayTypeEnum.Insurance || Part.PBy === enums_1.PayTypeEnum.Shared) {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ECGST, Part.ESGST, Part.EIGST);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetInsuranceTotalBasedOnTaxType(SubTotal, LaborTaxAmount, PartsTaxAmount, IsTaxable) {
+        let InsTotal = 0;
+        if (IsTaxable) {
+            InsTotal = (0, aggregation_1.addition)(SubTotal, LaborTaxAmount, PartsTaxAmount);
+        }
+        else {
+            InsTotal = (SubTotal);
+        }
+        return InsTotal;
+    }
+    static GetDetailedTotalsData(argRecordData, dupRecordData, TaxCodes, isWorkOrder) {
+        argRecordData.InsLaborDiscTotal = 0;
+        argRecordData.InsPartsDiscTotal = 0;
+        argRecordData.InsLaborTotalAfterDisc = this.GetInsLaborTotalAfterDiscount(dupRecordData.Ops);
+        argRecordData.InsPartsTotalAfterDisc = this.GetInsPartsTotalAfterDiscount(dupRecordData.Parts);
+        argRecordData.InsLaborTotalBeforeDisc = (0, aggregation_1.addition)(argRecordData.InsLaborTotalAfterDisc, argRecordData.InsLaborDiscTotal);
+        argRecordData.InsPartsTotalBeforeDisc = (0, aggregation_1.addition)(argRecordData.InsPartsTotalAfterDisc, argRecordData.InsPartsDiscTotal);
+        argRecordData.InsLaborITax = this.GetInsLaborTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsLaborCGST = this.GetInsLaborCGSTTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsLaborIGST = this.GetInsLaborIGSTTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsLaborSGST = this.GetInsLaborSGSTTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsPartITax = this.GetInsPartsTaxTotal(dupRecordData.Parts, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsPartCGST = this.GetInsPartCGSTTaxTotal(dupRecordData.Parts, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsPartIGST = this.GetInsPartIGSTTaxTotal(dupRecordData.Parts, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsPartSGST = this.GetInsPartSGSTTaxTotal(dupRecordData.Parts, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsLaborTotalAfterTax = (0, aggregation_1.addition)(argRecordData.InsLaborTotalAfterDisc, argRecordData.InsLaborITax);
+        argRecordData.InsPartsTotalAfterTax = (0, aggregation_1.addition)(argRecordData.InsPartsTotalAfterDisc, argRecordData.InsPartITax);
+        argRecordData.CustLaborDiscTotal = this.GetCustLaborDiscountedTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);
+        argRecordData.CustPartsDiscTotal = this.GetCustPartDiscountedTotal(dupRecordData.Parts, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);
+        argRecordData.CustLaborTotalAfterDisc = this.GetCustLaborTotalAfterDiscount(dupRecordData.Ops);
+        argRecordData.CustPartsTotalAfterDisc = this.GetCustPartsTotalAfterDiscount(dupRecordData.Parts);
+        argRecordData.CustLaborTotalBeforeDisc = (0, aggregation_1.addition)(argRecordData.CustLaborTotalAfterDisc, argRecordData.CustLaborDiscTotal);
+        argRecordData.CustPartsTotalBeforeDisc = (0, aggregation_1.addition)(argRecordData.CustPartsTotalAfterDisc, argRecordData.CustPartsDiscTotal);
+        argRecordData.CustLaborITax = this.GetCustLaborTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustLaborSGST = this.GetCustLaborSGSTTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustLaborCGST = this.GetCustLaborCGSTTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustLaborIGST = this.GetCustLaborIGSTTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustPartITax = this.GetCustPartsTaxTotal(dupRecordData.Ops, dupRecordData.Parts, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustPartCGST = this.GetCustPartCGSTTaxTotal(dupRecordData.Ops, dupRecordData.Parts, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustPartIGST = this.GetCustPartIGSTTaxTotal(dupRecordData.Ops, dupRecordData.Parts, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustPartSGST = this.GetCustPartSGSTTaxTotal(dupRecordData.Ops, dupRecordData.Parts, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustLaborLDiscAmount = this.GetLaborLDiscAmount(argRecordData.CustLaborTotalAfterDisc, argRecordData.LDisc);
+        argRecordData.CustPartsPDiscAmount = this.GetPartsPDiscAmount(argRecordData.CustPartsTotalAfterDisc, argRecordData.PDisc);
+        argRecordData.CustLaborAfterLDisc = argRecordData.CustLaborTotalAfterDisc;
+        argRecordData.CustPartsAfterPDisc = argRecordData.CustPartsTotalAfterDisc;
+        argRecordData.CustLaborAfterTax = (0, aggregation_1.addition)(argRecordData.CustLaborITax, argRecordData.CustLaborAfterLDisc);
+        argRecordData.CustPartAfterTax = (0, aggregation_1.addition)(argRecordData.CustPartITax, argRecordData.CustPartsAfterPDisc);
+        argRecordData.CustTaxGroupData = this.GetCustPartsTaxGrouping(dupRecordData.Parts, TaxCodes, isWorkOrder);
+        argRecordData.InsTaxGroupData = this.GetInsPartsTaxGrouping(dupRecordData.Parts, TaxCodes);
+        argRecordData.CustTotalRoundedBy = argRecordData.Round;
+        argRecordData.InsTotalRoundedBy = tr_utils_1.TrUtils.FixedTo((0, aggregation_1.subtraction)(Math.round(argRecordData.InsTotal), argRecordData.InsTotal));
+        argRecordData.CustRoundedTotal = argRecordData.Total;
+        argRecordData.InsRoundedTotal = Math.round(argRecordData.InsTotal);
+        for (var key in argRecordData) {
+            if (key !== 'Total' && key !== 'InsTotal' && key !== 'SubTotal' &&
+                key !== 'LDisc' && key !== 'LPerc' && key !== 'PDisc' &&
+                key !== 'PPerc' && key !== 'Disc' && key !== 'Perc' && key !== 'Tax'
+                && typeof argRecordData[key] === 'number') {
+                argRecordData[key] = tr_utils_1.TrUtils.FixPriceValue(argRecordData[key]);
+            }
+        }
+        return argRecordData;
+    }
+    static GetCustLaborDiscountedTotal(LaborList, isTaxable, finalTotalsData) {
+        let LaborDiscountedTotal = 0;
+        let overallLaborDisc = 0;
+        if (!isTaxable) {
+            overallLaborDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(finalTotalsData.LDisc);
+        }
+        LaborList.forEach((Labor) => {
+            LaborDiscountedTotal = (0, aggregation_1.addition)(LaborDiscountedTotal, Labor.CustDiscountedPrice);
+        });
+        return (0, aggregation_1.addition)(LaborDiscountedTotal, overallLaborDisc);
+    }
+    static GetCustPartDiscountedTotal(PartsList, isTaxable, finalTotalsData) {
+        let PartsDiscountedTotal = 0;
+        let overallPartDisc = 0;
+        if (!isTaxable) {
+            overallPartDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(finalTotalsData.PDisc);
+        }
+        PartsList.forEach((Part) => {
+            PartsDiscountedTotal = (0, aggregation_1.addition)(PartsDiscountedTotal, Part.CustDiscountedPrice);
+        });
+        return (0, aggregation_1.addition)(PartsDiscountedTotal, overallPartDisc);
+    }
+    static GetCustLaborCGSTTaxTotal(opCodesList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor) => {
+                if (isWorkOrder) {
+                    TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.CCGST);
+                }
+                else {
+                    if (Labor.Sts !== enums_1.LaborStatusEnum.New && Labor.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.CCGST);
+                    }
+                    else {
+                        if (Labor.PBy === enums_1.PayTypeEnum.Customer) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.ECGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetCustLaborIGSTTaxTotal(opCodesList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor) => {
+                if (isWorkOrder) {
+                    TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.CIGST);
+                }
+                else {
+                    if (Labor.Sts !== enums_1.LaborStatusEnum.New && Labor.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.CIGST);
+                    }
+                    else {
+                        if (Labor.PBy === enums_1.PayTypeEnum.Customer) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.EIGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetCustLaborSGSTTaxTotal(opCodesList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor) => {
+                if (isWorkOrder) {
+                    TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.CSGST);
+                }
+                else {
+                    if (Labor.Sts !== enums_1.LaborStatusEnum.New && Labor.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.CSGST);
+                    }
+                    else {
+                        if (Labor.PBy === enums_1.PayTypeEnum.Customer) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.ESGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetCustPartCGSTTaxTotal(OpsList, PartsList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part) => {
+                if (!tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CCGST);
+                    }
+                    else {
+                        if (Part.Sts !== enums_1.LaborStatusEnum.New && Part.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CCGST);
+                        }
+                        else {
+                            if (Part.PBy === enums_1.PayTypeEnum.Customer) {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ECGST);
+                            }
+                        }
+                    }
+                }
+                else {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CCGST);
+                    }
+                    else {
+                        let Index = OpsList.findIndex((labor) => {
+                            return labor._id === Part.OpId;
+                        });
+                        if (Index !== -1) {
+                            if (OpsList[Index].Sts !== enums_1.LaborStatusEnum.New && OpsList[Index].Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CCGST);
+                            }
+                            else {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ECGST);
+                            }
+                        }
+                        else {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CCGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetCustPartIGSTTaxTotal(OpsList, PartsList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part) => {
+                if (!tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CIGST);
+                    }
+                    else {
+                        if (Part.Sts !== enums_1.LaborStatusEnum.New && Part.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CIGST);
+                        }
+                        else {
+                            if (Part.PBy === enums_1.PayTypeEnum.Customer) {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.EIGST);
+                            }
+                        }
+                    }
+                }
+                else {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CIGST);
+                    }
+                    else {
+                        let Index = OpsList.findIndex((labor) => {
+                            return labor._id === Part.OpId;
+                        });
+                        if (Index !== -1) {
+                            if (OpsList[Index].Sts !== enums_1.LaborStatusEnum.New && OpsList[Index].Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CIGST);
+                            }
+                            else {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.EIGST);
+                            }
+                        }
+                        else {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CIGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetCustPartSGSTTaxTotal(OpsList, PartsList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part) => {
+                if (!tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CSGST);
+                    }
+                    else {
+                        if (Part.Sts !== enums_1.LaborStatusEnum.New && Part.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CSGST);
+                        }
+                        else {
+                            if (Part.PBy === enums_1.PayTypeEnum.Customer) {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ESGST);
+                            }
+                        }
+                    }
+                }
+                else {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CSGST);
+                    }
+                    else {
+                        let Index = OpsList.findIndex((labor) => {
+                            return labor._id === Part.OpId;
+                        });
+                        if (Index !== -1) {
+                            if (OpsList[Index].Sts !== enums_1.LaborStatusEnum.New && OpsList[Index].Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CSGST);
+                            }
+                            else {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ESGST);
+                            }
+                        }
+                        else {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CSGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetInsLaborCGSTTaxTotal(opCodesList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor) => {
+                if (isWorkOrder) {
+                    TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.ACGST);
+                }
+                else {
+                    if (Labor.Sts !== enums_1.LaborStatusEnum.New && Labor.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.ACGST);
+                    }
+                    else {
+                        if (Labor.PBy === enums_1.PayTypeEnum.Insurance || Labor.PBy === enums_1.PayTypeEnum.Shared) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.ECGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetInsLaborIGSTTaxTotal(opCodesList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor) => {
+                if (isWorkOrder) {
+                    TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.AIGST);
+                }
+                else {
+                    if (Labor.Sts !== enums_1.LaborStatusEnum.New && Labor.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.AIGST);
+                    }
+                    else {
+                        if (Labor.PBy === enums_1.PayTypeEnum.Insurance || Labor.PBy === enums_1.PayTypeEnum.Shared) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.EIGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetInsLaborSGSTTaxTotal(opCodesList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor) => {
+                if (isWorkOrder) {
+                    TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.ASGST);
+                }
+                else {
+                    if (Labor.Sts !== enums_1.LaborStatusEnum.New && Labor.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.ASGST);
+                    }
+                    else {
+                        if (Labor.PBy === enums_1.PayTypeEnum.Insurance || Labor.PBy === enums_1.PayTypeEnum.Shared) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.ESGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetInsPartCGSTTaxTotal(PartsList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part) => {
+                if (!tr_utils_1.TrUtils.IsNull(Part.CollId) || Part.PBy === enums_1.PayTypeEnum.Insurance || Part.PBy === enums_1.PayTypeEnum.Shared) {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ACGST);
+                    }
+                    else {
+                        if (Part.Sts !== enums_1.LaborStatusEnum.New && Part.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ACGST);
+                        }
+                        else {
+                            if (Part.PBy === enums_1.PayTypeEnum.Insurance || Part.PBy === enums_1.PayTypeEnum.Shared) {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ECGST);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetInsPartIGSTTaxTotal(PartsList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part) => {
+                if (!tr_utils_1.TrUtils.IsNull(Part.CollId) || Part.PBy === enums_1.PayTypeEnum.Insurance || Part.PBy === enums_1.PayTypeEnum.Shared) {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.AIGST);
+                    }
+                    else {
+                        if (Part.Sts !== enums_1.LaborStatusEnum.New && Part.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.AIGST);
+                        }
+                        else {
+                            if (Part.PBy === enums_1.PayTypeEnum.Insurance || Part.PBy === enums_1.PayTypeEnum.Shared) {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.EIGST);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetInsPartSGSTTaxTotal(PartsList, IsTaxable, isWorkOrder) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part) => {
+                if (!tr_utils_1.TrUtils.IsNull(Part.CollId) || Part.PBy === enums_1.PayTypeEnum.Insurance || Part.PBy === enums_1.PayTypeEnum.Shared) {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ASGST);
+                    }
+                    else {
+                        if (Part.Sts !== enums_1.LaborStatusEnum.New && Part.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ASGST);
+                        }
+                        else {
+                            if (Part.PBy === enums_1.PayTypeEnum.Insurance || Part.PBy === enums_1.PayTypeEnum.Shared) {
+                                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.ESGST);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetLaborLDiscAmount(LaborTotalAfterDisc, LDisc) {
+        let LaborLDiscAmt = 0;
+        if (!tr_utils_1.TrUtils.IsZero(LaborTotalAfterDisc)) {
+            LaborLDiscAmt = LDisc;
+        }
+        return LaborLDiscAmt;
+    }
+    static GetPartsPDiscAmount(PartsTotalAfterDisc, PDisc) {
+        let PartsPDiscAmt = 0;
+        if (!tr_utils_1.TrUtils.IsZero(PartsTotalAfterDisc)) {
+            PartsPDiscAmt = PDisc;
+        }
+        return PartsPDiscAmt;
+    }
+    static GetCustPartsTaxGrouping(PartsList, TaxCodes, isWorkOrder) {
+        let FilteredPartsList = this.GetCustParts(PartsList);
+        return this.GetCustTaxGroupingForPartsByHSN(FilteredPartsList, TaxCodes, isWorkOrder);
+    }
+    static GetCustParts(PartsList) {
+        let FilteredPartsList = PartsList.filter((Part) => {
+            return Part.PBy === enums_1.PayTypeEnum.Customer || Part.PBy === enums_1.PayTypeEnum.Shared;
+        });
+        return FilteredPartsList;
+    }
+    static GetCustTaxGroupingForPartsByHSN(Parts, TaxCodes, isWorkOrder) {
+        Parts = this.GetCombinedTaxPercentage(Parts, TaxCodes);
+        Parts = this.ResetPartsHSNIfInvalid(Parts);
+        let FinalMatchedParts = this.ComparePartsByHSN(Parts, TaxCodes);
+        return this.GetCustTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes, isWorkOrder);
+    }
+    static GetCustTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes, isWorkOrder) {
+        let HSNTaxInfo = [];
+        FinalMatchedParts.forEach((MatchedPart) => {
+            let TaxInfo = {};
+            let TaxOnAmount = 0;
+            let TaxAmount = 0;
+            let HSN = MatchedPart[0].HSN;
+            TaxInfo.CombinedTaxPercentage = MatchedPart[0].CombinedTaxPercentage;
+            MatchedPart.forEach((argMatchedGSTPart) => {
+                TaxOnAmount = (0, aggregation_1.addition)(TaxOnAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.CustAfterPartDisc));
+                if (isWorkOrder) {
+                    TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.CCGST));
+                    TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.CIGST));
+                    TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.CSGST));
+                }
+                else {
+                    if (argMatchedGSTPart.Sts !== enums_1.LaborStatusEnum.New && argMatchedGSTPart.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                        TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.CCGST));
+                        TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.CIGST));
+                        TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.CSGST));
+                    }
+                    else {
+                        if (argMatchedGSTPart.PBy === enums_1.PayTypeEnum.Customer) {
+                            TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.ECGST));
+                            TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.EIGST));
+                            TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.ESGST));
+                        }
+                    }
+                }
+            });
+            TaxInfo.HSN = HSN;
+            TaxInfo.TotalTaxableAmount = tr_utils_1.TrUtils.FixPriceValue(TaxOnAmount);
+            TaxInfo.TotalTaxAmount = tr_utils_1.TrUtils.FixPriceValue(TaxAmount);
+            TaxInfo.PartsCount = MatchedPart.length;
+            let GSTValues = this.GetGSTValueBasedOnTaxCode(MatchedPart[0].TCode, TaxCodes);
+            TaxInfo.CGST = GSTValues[0];
+            TaxInfo.SGST = GSTValues[1];
+            TaxInfo.IGST = GSTValues[2];
+            if (TaxOnAmount !== 0) {
+                HSNTaxInfo.push(TaxInfo);
+            }
+        });
+        return HSNTaxInfo;
+    }
+    static GetInsPartsTaxGrouping(PartsList, TaxCodes) {
+        let FilteredPartsList = this.GetInsParts(PartsList);
+        return this.GetInsTaxGroupingForPartsByHSN(FilteredPartsList, TaxCodes);
+    }
+    static GetInsParts(PartsList) {
+        let FilteredPartsList = PartsList.filter((Part) => {
+            return Part.PBy === enums_1.PayTypeEnum.Insurance || Part.PBy === enums_1.PayTypeEnum.Shared;
+        });
+        return FilteredPartsList;
+    }
+    static GetInsTaxGroupingForPartsByHSN(Parts, TaxCodes) {
+        Parts = this.GetCombinedTaxPercentage(Parts, TaxCodes);
+        Parts = this.ResetPartsHSNIfInvalid(Parts);
+        let FinalMatchedParts = this.ComparePartsByHSN(Parts, TaxCodes);
+        return this.GetInsTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes);
+    }
+    static GetInsTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes) {
+        let HSNTaxInfo = [];
+        FinalMatchedParts.forEach((MatchedPart) => {
+            let TaxInfo = {};
+            let TaxOnAmount = 0;
+            let TaxAmount = 0;
+            let HSN = MatchedPart[0].HSN;
+            TaxInfo.CombinedTaxPercentage = MatchedPart[0].CombinedTaxPercentage;
+            MatchedPart.forEach((argMatchedGSTPart) => {
+                TaxOnAmount = (0, aggregation_1.addition)(TaxOnAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.InsAfterPartDisc));
+                if (argMatchedGSTPart.PBy === enums_1.PayTypeEnum.Insurance || argMatchedGSTPart.PBy === enums_1.PayTypeEnum.Shared) {
+                    if (argMatchedGSTPart.Sts !== enums_1.LaborStatusEnum.New && argMatchedGSTPart.Sts !== enums_1.LaborStatusEnum.WtngForAppr) {
+                        TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.ACGST));
+                        TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.AIGST));
+                        TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.ASGST));
+                    }
+                    else {
+                        TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.ECGST));
+                        TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.EIGST));
+                        TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.ESGST));
+                    }
+                }
+            });
+            TaxInfo.HSN = HSN;
+            TaxInfo.TotalTaxableAmount = tr_utils_1.TrUtils.FixPriceValue(TaxOnAmount);
+            TaxInfo.TotalTaxAmount = tr_utils_1.TrUtils.FixPriceValue(TaxAmount);
+            TaxInfo.PartsCount = MatchedPart.length;
+            let GSTValues = this.GetGSTValueBasedOnTaxCode(MatchedPart[0].TCode, TaxCodes);
+            TaxInfo.CGST = GSTValues[0];
+            TaxInfo.SGST = GSTValues[1];
+            TaxInfo.IGST = GSTValues[2];
+            if (TaxOnAmount !== 0) {
+                HSNTaxInfo.push(TaxInfo);
+            }
+        });
+        return HSNTaxInfo;
+    }
+    static GetGSTValueBasedOnTaxCode(TCode, TaxCodes) {
+        let CGST = 0;
+        let SGST = 0;
+        let IGST = 0;
+        if (tr_utils_1.TrUtils.IsNull(TCode)) {
+            return [CGST, SGST, IGST];
+        }
+        let TCodeIndex = TaxCodes.findIndex((TaxCode) => {
+            return TaxCode._id === Number(TCode);
+        });
+        if (TCodeIndex !== -1) {
+            if (TaxCodes[TCodeIndex].Type === 'Intra') {
+                return [TaxCodes[TCodeIndex].CGST, TaxCodes[TCodeIndex].SGST, 0];
+            }
+            else {
+                return [0, 0, TaxCodes[TCodeIndex].IGST];
+            }
+        }
+        else {
+            return [CGST, SGST, IGST];
+        }
+    }
+    static GetCombinedTaxPercentage(Parts, TaxCodes) {
+        Parts.forEach((Part) => {
+            let GSTValues = this.GetGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+            let CGST = GSTValues[0];
+            let SGST = GSTValues[1];
+            let IGST = GSTValues[2];
+            Part.CombinedTaxPercentage = (0, aggregation_1.addition)(CGST, SGST, IGST);
+        });
+        return Parts;
+    }
+    static ResetPartsHSNIfInvalid(Parts) {
+        Parts.forEach((Part) => {
+            if (tr_utils_1.TrUtils.IsNull(Part.HSN)) {
+                Part.HSN = '';
+            }
+        });
+        return Parts;
+    }
+    static ComparePartsByHSN(Parts, TaxCodes) {
+        let FinalMatchedParts = [];
+        Parts.forEach((Part) => {
+            let MatchedPartsBasedOnHSN = Parts.filter((argPart) => {
+                let PartFound = false;
+                FinalMatchedParts.forEach((FinalArgParts) => {
+                    let PartIndex = FinalArgParts.findIndex((FinalArgPart) => {
+                        return FinalArgPart._id === argPart._id;
+                    });
+                    if (PartIndex !== -1) {
+                        PartFound = true;
+                    }
+                });
+                let argGSTValues = this.GetGSTValueBasedOnTaxCode(argPart.TCode, TaxCodes);
+                let argCGST = argGSTValues[0];
+                let argSGST = argGSTValues[1];
+                let argIGST = argGSTValues[2];
+                let partGSTValues = this.GetGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+                let partCGST = partGSTValues[0];
+                let partSGST = partGSTValues[1];
+                let partIGST = partGSTValues[2];
+                return (argPart.HSN === Part.HSN) && (!PartFound) &&
+                    (argCGST === partCGST) && (argIGST === partIGST) &&
+                    (argSGST === partSGST);
+            });
+            if (MatchedPartsBasedOnHSN.length !== 0) {
+                FinalMatchedParts.push(MatchedPartsBasedOnHSN);
+            }
+        });
+        return FinalMatchedParts;
+    }
+}
+exports.ROTotalsService = ROTotalsService;