shareneus 1.7.4 → 1.7.6

package/src/services/ro-totals.service.ts

@@ -0,0 +1,1314 @@
+import { LaborStatusEnum, PayTypeEnum } from "../enums/enums";
+import { Add, Divide, Subtract } from "../shared/math-operations";
+import { TrUtils } from "../utils/tr-utils";
+
+
+export class ROTotalsService {
+
+    static GetTaxAmountFromGroup(item: any, taxGroupKey: string, taxCode: string, fallbackKey: string) {
+        const groupedTaxes = item?.[taxGroupKey];
+        if (Array.isArray(groupedTaxes)) {
+            const matchedTaxes = groupedTaxes.filter((tax: any) => tax?.Code === taxCode);
+            if (matchedTaxes.length !== 0) {
+                return matchedTaxes.reduce((total: number, tax: any) => Add(total, tax?.Amt), 0);
+            }
+        }
+        return TrUtils.SetValueToZeroIfNull(item?.[fallbackKey]);
+    }
+
+    static GetTotalsValue(OriRecordData: any, TaxCodes: any[], isWorkOrder: boolean, detailedInfo: boolean, withItems: boolean, isRoundable: boolean, EntitySettings: any) {
+
+        let dupRecordData: any = TrUtils.Stringify(OriRecordData);
+        let argRecordData: any = {};
+        dupRecordData.Ops = this.CalculateLaborValues(dupRecordData.Ops, isWorkOrder, TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        dupRecordData.Parts = this.CalculatePartValues(dupRecordData.Parts, dupRecordData.Ops, isWorkOrder, TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        argRecordData = this.GetROTotalsData(argRecordData, dupRecordData, TaxCodes, withItems, detailedInfo, isWorkOrder, isRoundable, EntitySettings.DecimalsNumber);
+
+        return argRecordData;
+    }
+
+    static CalculateLaborValues(opCodesList: any, isWorkOrder: boolean, isTaxable: boolean) {
+
+        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: any[]) {
+        opCodesList = opCodesList.filter((Labor: any) => {
+            return Labor.Sts !== LaborStatusEnum.Cancelled && Labor.Sts !== LaborStatusEnum.Declined;
+        });
+        return opCodesList;
+    }
+
+    static ResetLaborValuesIfInvalid(opCodesList: any, isWorkOrder: boolean) {
+        opCodesList.forEach((Operation: any) => {
+            Operation = this.ResetLaborValueIfInvalid(Operation, isWorkOrder);
+        });
+        return opCodesList;
+    }
+
+    static ResetLaborValueIfInvalid(Operation: any, isWorkOrder: boolean) {
+        Operation.Perc = TrUtils.SetPercToStringIfNull(Operation.Perc);
+        Operation.Disc = TrUtils.SetValueToZeroIfNull(Operation.Disc);
+        Operation.Pr = TrUtils.SetValueToZeroIfNull(Operation.Pr);
+        Operation.AssPr = TrUtils.SetValueToZeroIfNull(Operation.AssPr);
+        Operation.ACGST = this.GetTaxAmountFromGroup(Operation, 'ATaxes', 'CGST', 'ACGST');
+        Operation.ASGST = this.GetTaxAmountFromGroup(Operation, 'ATaxes', 'SGST', 'ASGST');
+        Operation.AIGST = this.GetTaxAmountFromGroup(Operation, 'ATaxes', 'IGST', 'AIGST');
+        Operation.CCGST = this.GetTaxAmountFromGroup(Operation, 'CTaxes', 'CGST', 'CCGST');
+        Operation.CSGST = this.GetTaxAmountFromGroup(Operation, 'CTaxes', 'SGST', 'CSGST');
+        Operation.CIGST = this.GetTaxAmountFromGroup(Operation, 'CTaxes', 'IGST', 'CIGST');
+        Operation.NetAmt = TrUtils.SetValueToZeroIfNull(Operation.NetAmt);
+        Operation.RecDisc = TrUtils.SetValueToZeroIfNull(Operation.RecDisc);
+
+        if (!isWorkOrder) {
+            Operation.EstPr = TrUtils.SetValueToZeroIfNull(Operation.EstPr);
+            Operation.ECGST = this.GetTaxAmountFromGroup(Operation, 'ETaxes', 'CGST', 'ECGST');
+            Operation.ESGST = this.GetTaxAmountFromGroup(Operation, 'ETaxes', 'SGST', 'ESGST');
+            Operation.EIGST = this.GetTaxAmountFromGroup(Operation, 'ETaxes', 'IGST', 'EIGST');
+        }
+        return Operation;
+    }
+
+    static GetOperationsDiscountPrice(OperationsList: any, isWorkOrder: boolean) {
+        OperationsList.forEach((Operation: any) => {
+            if (isWorkOrder) {
+                Operation.CustDiscountedPrice = Add(Operation.Disc, Operation.RecDisc);
+            } else {
+                if (Operation.Sts === LaborStatusEnum.New || Operation.Sts === LaborStatusEnum.WtngForAppr) {
+                    Operation.CustDiscountedPrice = 0;
+                } else {
+                    Operation.CustDiscountedPrice = Add(Operation.Disc, Operation.RecDisc);
+                }
+            }
+        });
+        return OperationsList;
+    }
+
+    static GetOperationsAfterDiscount(OperationsList: any, isWorkOrder: boolean) {
+        OperationsList.forEach((Operation: any) => {
+            let CustAfterLaborDisc: number = 0;
+            let InsAfterLaborDisc: number = 0;
+            if (Operation.PBy === PayTypeEnum.Customer) {
+                if (isWorkOrder) {
+                    CustAfterLaborDisc = Operation.NetAmt;
+                } else {
+                    if (Operation.Sts === LaborStatusEnum.New || Operation.Sts === LaborStatusEnum.WtngForAppr) {
+                        CustAfterLaborDisc = Operation.EstPr;
+                    } else {
+                        CustAfterLaborDisc = Operation.NetAmt;
+                    }
+                }
+            } else {
+                if (isWorkOrder) {
+                    CustAfterLaborDisc = Operation.NetAmt;
+                    InsAfterLaborDisc = Operation.AssPr;
+                } else {
+                    if (Operation.Sts === LaborStatusEnum.New || Operation.Sts === LaborStatusEnum.WtngForAppr) {
+                        InsAfterLaborDisc = Operation.EstPr;
+                    } else {
+                        CustAfterLaborDisc = Operation.NetAmt;
+                        InsAfterLaborDisc = Operation.AssPr;
+                    }
+                }
+            }
+            Operation.CustAfterLaborDisc = CustAfterLaborDisc;
+            Operation.InsAfterLaborDisc = InsAfterLaborDisc;
+        });
+        return OperationsList;
+    }
+
+    static GetOperationsAfterTax(OperationsList: any, isWorkOrder: boolean, isTaxable: boolean) {
+        OperationsList.forEach((Operation: any) => {
+            if (!isTaxable) {
+                Operation.CustAfterTax = Operation.CustAfterLaborDisc;
+                Operation.InsAfterTax = Operation.InsAfterLaborDisc;
+            } else {
+                if (Operation.PBy === PayTypeEnum.Customer) {
+                    if (isWorkOrder) {
+                        Operation.CustAfterTax = Add(Operation.CustAfterLaborDisc, Operation.CCGST, Operation.CSGST, Operation.CIGST);
+                    } else {
+                        if (Operation.Sts !== LaborStatusEnum.New && Operation.Sts !== LaborStatusEnum.WtngForAppr) {
+                            Operation.CustAfterTax = Add(Operation.CustAfterLaborDisc, Operation.CCGST, Operation.CSGST, Operation.CIGST);
+                        } else {
+                            Operation.CustAfterTax = Add(Operation.CustAfterLaborDisc, Operation.ECGST, Operation.ESGST, Operation.EIGST);
+                        }
+                    }
+                    Operation.InsAfterTax = 0;
+                } else {
+                    if (isWorkOrder) {
+                        Operation.CustAfterTax = Add(Operation.CustAfterLaborDisc, Operation.CCGST, Operation.CSGST, Operation.CIGST);
+                        Operation.InsAfterTax = Add(Operation.InsAfterLaborDisc, Operation.ACGST, Operation.ASGST, Operation.AIGST);
+                    } else {
+                        if (Operation.Sts !== LaborStatusEnum.New && Operation.Sts !== LaborStatusEnum.WtngForAppr) {
+                            Operation.CustAfterTax = Add(Operation.CustAfterLaborDisc, Operation.CCGST, Operation.CSGST, Operation.CIGST);
+                            Operation.InsAfterTax = Add(Operation.InsAfterLaborDisc, Operation.ACGST, Operation.ASGST, Operation.AIGST);
+                        } else {
+                            Operation.CustAfterTax = 0;
+                            Operation.InsAfterTax = Add(Operation.InsAfterLaborDisc, Operation.ECGST, Operation.ESGST, Operation.EIGST);
+                        }
+                    }
+                }
+            }
+        });
+        return OperationsList;
+    }
+
+    static CalculatePartValues(PartsList: any, LaborList: any, isWorkOrder: boolean, isTaxable: boolean) {
+
+        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: any[]) {
+        PartsList = PartsList.filter((Part: any) => {
+            if (TrUtils.IsNull(Part.CollId)) {
+                return Part;
+            } else {
+                return Part.Sts !== LaborStatusEnum.Cancelled && Part.Sts !== LaborStatusEnum.Declined;
+            }
+        });
+        return PartsList;
+    }
+
+    static ResetPartValuesIfInvalid(PartsList: any, isWorkOrder: boolean) {
+        PartsList.forEach((Part: any) => {
+            Part = this.ResetPartValueIfInvalid(Part, isWorkOrder);
+        });
+        return PartsList;
+    }
+
+    static ResetPartValueIfInvalid(Part: any, isWorkOrder: boolean) {
+        Part.Perc = TrUtils.SetPercToStringIfNull(Part.Perc);
+        Part.Disc = TrUtils.SetValueToZeroIfNull(Part.Disc);
+        Part.UnPr = TrUtils.SetValueToZeroIfNull(Part.UnPr);
+        Part.AssPr = TrUtils.SetValueToZeroIfNull(Part.AssPr);
+        Part.ACGST = this.GetTaxAmountFromGroup(Part, 'ATaxes', 'CGST', 'ACGST');
+        Part.ASGST = this.GetTaxAmountFromGroup(Part, 'ATaxes', 'SGST', 'ASGST');
+        Part.AIGST = this.GetTaxAmountFromGroup(Part, 'ATaxes', 'IGST', 'AIGST');
+        Part.CCGST = this.GetTaxAmountFromGroup(Part, 'CTaxes', 'CGST', 'CCGST');
+        Part.CSGST = this.GetTaxAmountFromGroup(Part, 'CTaxes', 'SGST', 'CSGST');
+        Part.CIGST = this.GetTaxAmountFromGroup(Part, 'CTaxes', 'IGST', 'CIGST');
+        Part.UnAmt = TrUtils.SetValueToZeroIfNull(Part.UnAmt);
+        Part.AssAmt = TrUtils.SetValueToZeroIfNull(Part.AssAmt);
+        Part.NetAmt = TrUtils.SetValueToZeroIfNull(Part.NetAmt);
+        Part.RecDisc = TrUtils.SetValueToZeroIfNull(Part.RecDisc);
+        if (!isWorkOrder) {
+            Part.EstPr = TrUtils.SetValueToZeroIfNull(Part.EstPr);
+            Part.ECGST = this.GetTaxAmountFromGroup(Part, 'ETaxes', 'CGST', 'ECGST');
+            Part.ESGST = this.GetTaxAmountFromGroup(Part, 'ETaxes', 'SGST', 'ESGST');
+            Part.EIGST = this.GetTaxAmountFromGroup(Part, 'ETaxes', 'IGST', 'EIGST');
+            Part.EstAmt = TrUtils.SetValueToZeroIfNull(Part.EstAmt);
+        }
+        return Part;
+    }
+
+    static GetPartsDiscountPrice(PartsList: any, LaborList: any, isWorkOrder: boolean) {
+        PartsList.forEach((Part: any) => {
+            if (TrUtils.IsNull(Part.CollId)) {
+                if (isWorkOrder) {
+                    Part.CustDiscountedPrice = Add(Part.Disc, Part.RecDisc);
+                } else {
+                    let LaborSts: string = this.GetPartParentStatus(Part, LaborList);
+                    if (LaborSts === LaborStatusEnum.New || LaborSts === LaborStatusEnum.WtngForAppr) {
+                        Part.CustDiscountedPrice = 0;
+                    } else {
+                        Part.CustDiscountedPrice = Add(Part.Disc, Part.RecDisc);
+                    }
+                }
+            } else {
+                if (isWorkOrder) {
+                    Part.CustDiscountedPrice = Add(Part.Disc, Part.RecDisc);
+                } else {
+                    if (Part.Sts === LaborStatusEnum.New || Part.Sts === LaborStatusEnum.WtngForAppr) {
+                        Part.CustDiscountedPrice = 0;
+                    } else {
+                        Part.CustDiscountedPrice = Add(Part.Disc, Part.RecDisc);
+                    }
+                }
+            }
+        });
+        return PartsList;
+    }
+
+    static GetPartParentStatus(Part: any, LaborList: any) {
+        if (!TrUtils.IsNull(Part.OpId)) {
+            let index: number = LaborList.findIndex((Labor: any) => {
+                return Labor._id === Part.OpId;
+            });
+            return LaborList[index].Sts;
+        } else {
+            return Part.Sts;
+        }
+
+    }
+
+    static GetPartsAfterDiscount(PartsList: any, LaborList: any, isWorkOrder: boolean) {
+        PartsList.forEach((Part: any) => {
+            if (TrUtils.IsNull(Part.CollId)) {
+                let CustAfterPartDisc: number = 0;
+                let InsAfterPartDisc: number = 0;
+                if (isWorkOrder) {
+                    CustAfterPartDisc = Part.NetAmt;
+                    if (TrUtils.IsNull(Part.OpId)) {
+                        InsAfterPartDisc = Part.AssAmt;
+                    }
+                } else {
+                    let LaborSts: string = this.GetPartParentStatus(Part, LaborList);
+                    if (LaborSts === LaborStatusEnum.New || LaborSts === LaborStatusEnum.WtngForAppr) {
+                        CustAfterPartDisc = Part.EstAmt;
+                    } else {
+                        CustAfterPartDisc = Part.NetAmt;
+                        if (TrUtils.IsNull(Part.OpId)) {
+                            InsAfterPartDisc = Part.AssAmt;
+                        }
+                    }
+                }
+                Part.CustAfterPartDisc = CustAfterPartDisc;
+                Part.InsAfterPartDisc = InsAfterPartDisc;
+            } else {
+                let CustAfterPartDisc: number = 0;
+                let InsAfterPartDisc: number = 0;
+                if (Part.PBy === PayTypeEnum.Customer) {
+                    if (isWorkOrder) {
+                        CustAfterPartDisc = Part.NetAmt;
+                    } else {
+                        if (Part.Sts === LaborStatusEnum.New || Part.Sts === LaborStatusEnum.WtngForAppr) {
+                            CustAfterPartDisc = Part.EstAmt;
+                        } else {
+                            CustAfterPartDisc = Part.NetAmt;
+                        }
+                    }
+                } else {
+                    if (isWorkOrder) {
+                        CustAfterPartDisc = Part.NetAmt;
+                        InsAfterPartDisc = Part.AssAmt;
+                    } else {
+                        if (Part.Sts === LaborStatusEnum.New || Part.Sts === LaborStatusEnum.WtngForAppr) {
+                            InsAfterPartDisc = Part.EstAmt;
+                        } else {
+                            CustAfterPartDisc = Part.NetAmt;
+                            InsAfterPartDisc = Part.AssAmt;
+                        }
+                    }
+                }
+                Part.CustAfterPartDisc = CustAfterPartDisc;
+                Part.InsAfterPartDisc = InsAfterPartDisc;
+            }
+        });
+        return PartsList;
+    }
+
+    static GetPartsAfterTax(PartsList: any, LaborList: any, isWorkOrder: boolean, isTaxable: boolean) {
+        PartsList.forEach((Part: any) => {
+            if (!isTaxable) {
+                Part.CustAfterTax = Part.CustAfterPartDisc;
+                Part.InsAfterTax = Part.InsAfterPartDisc;
+            } else {
+                if (TrUtils.IsNull(Part.CollId)) {
+                    if (isWorkOrder) {
+                        Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
+                        if (TrUtils.IsNull(Part.OpId)) {
+                            Part.InsAfterTax = Add(Part.InsAfterPartDisc, Part.ACGST, Part.ASGST, Part.AIGST);
+                        }
+                    } else {
+                        let LaborSts: string = this.GetPartParentStatus(Part, LaborList);
+                        if (LaborSts === LaborStatusEnum.New || LaborSts === LaborStatusEnum.WtngForAppr) {
+                            Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.ECGST, Part.ESGST, Part.EIGST);
+                        } else {
+                            Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
+                            if (TrUtils.IsNull(Part.OpId)) {
+                                Part.InsAfterTax = Add(Part.InsAfterPartDisc, Part.ACGST, Part.ASGST, Part.AIGST);
+                            }
+                        }
+                    }
+                    // Part.InsAfterTax = 0;
+
+                } else {
+                    if (Part.PBy === PayTypeEnum.Customer) {
+                        if (isWorkOrder) {
+                            Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
+                        } else {
+                            if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
+                                Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
+                            } else {
+                                Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.ECGST, Part.ESGST, Part.EIGST);
+                            }
+                        }
+                        Part.InsAfterTax = 0;
+                    } else {
+                        if (isWorkOrder) {
+                            Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
+                            Part.InsAfterTax = Add(Part.InsAfterPartDisc, Part.ACGST, Part.ASGST, Part.AIGST);
+                        } else {
+                            if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
+                                Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
+                                Part.InsAfterTax = Add(Part.InsAfterPartDisc, Part.ACGST, Part.ASGST, Part.AIGST);
+                            } else {
+                                Part.CustAfterTax = 0;
+                                Part.InsAfterTax = Add(Part.InsAfterPartDisc, Part.ECGST, Part.ESGST, Part.EIGST);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        return PartsList;
+    }
+
+    static GetPartsPerItemAfterTax(PartsList: any) {
+        PartsList.forEach((Part: any) => {
+            Part.CustAfterTaxPerItem = Divide(Part.CustAfterTax, Part.Qty);
+            Part.InsAfterTaxPerItem = Divide(Part.InsAfterTax, Part.Qty);
+        });
+        return PartsList;
+    }
+
+    static GetROTotalsData(argRecordData: any, dupRecordData: any, TaxCodes: any, withItems: boolean, detailedInfo: any, isWorkOrder: boolean, isRoundable: boolean, DecimalsNumber: number) {
+
+        dupRecordData = this.ResetDiscountValuesIfInvalid(dupRecordData);
+        argRecordData = this.SetMainDiscountValues(argRecordData, dupRecordData, detailedInfo);
+        argRecordData = this.GetFinalCustomerTotalsData(argRecordData, dupRecordData, isWorkOrder, detailedInfo, isRoundable, DecimalsNumber);
+        argRecordData = this.GetFinalInsuranceTotalsData(argRecordData, dupRecordData, detailedInfo, isWorkOrder, DecimalsNumber);
+        if (detailedInfo) {
+            argRecordData = this.GetDetailedTotalsData(argRecordData, dupRecordData, TaxCodes, isWorkOrder, DecimalsNumber);
+        }
+        if (withItems) {
+            argRecordData.Ops = dupRecordData.Ops;
+            argRecordData.Parts = dupRecordData.Parts;
+            argRecordData.Colli = dupRecordData.Colli;
+        }
+        return argRecordData;
+    }
+
+    static ResetDiscountValuesIfInvalid(dupRecordData: any) {
+        dupRecordData.LPerc = TrUtils.SetPercToStringIfNull(dupRecordData.LPerc);
+        dupRecordData.PPerc = TrUtils.SetPercToStringIfNull(dupRecordData.PPerc);
+        dupRecordData.Perc = TrUtils.SetPercToStringIfNull(dupRecordData.Perc);
+        dupRecordData.LDisc = TrUtils.SetValueToZeroIfNull(dupRecordData.LDisc);
+        dupRecordData.PDisc = TrUtils.SetValueToZeroIfNull(dupRecordData.PDisc);
+        dupRecordData.Disc = TrUtils.SetValueToZeroIfNull(dupRecordData.Disc);
+        return dupRecordData;
+    }
+
+    static SetMainDiscountValues(argRecordData: any, dupRecordData: any, detailedInfo: boolean) {
+        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: any, dupRecordData: any, isWorkOrder: boolean, detailedInfo: boolean, isRoundable: boolean, DecimalsNumber: number) {
+        let CustomerAfterDiscTotals: number = this.GetCustSubTotal(dupRecordData.Ops, dupRecordData.Parts);
+        let CustLaborTaxTotal = this.GetCustLaborTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        let CustPartTaxTotal = this.GetCustPartsTaxTotal(dupRecordData.Ops, dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        let CustLaborDiscTotal: any = this.GetCustLaborDiscountedTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);
+        let CustPartsDiscTotal: any = this.GetCustPartDiscountedTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);
+        let CustLaborTotalAfterDisc: any = this.GetCustLaborTotalAfterDiscount(dupRecordData.Ops);
+        let CustPartsTotalAfterDisc: any = this.GetCustPartsTotalAfterDiscount(dupRecordData.Parts);
+        argRecordData.STotal = Add(CustLaborDiscTotal, CustPartsDiscTotal, CustLaborTotalAfterDisc, CustPartsTotalAfterDisc)
+        argRecordData.CustLaborTotalBeforeDisc = Add(argRecordData.CustLaborTotalAfterDisc
+            , argRecordData.CustLaborDiscTotal);
+        argRecordData.CustPartsTotalBeforeDisc = Add(argRecordData.CustPartsTotalAfterDisc
+            , argRecordData.CustPartsDiscTotal);
+        argRecordData.SubTotal = TrUtils.FixedTo(CustomerAfterDiscTotals, DecimalsNumber);
+        let CustTotal: any = this.GetCustomerTotalBasedOnTaxType(dupRecordData, CustLaborTaxTotal, CustPartTaxTotal, dupRecordData.Ops, dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        argRecordData.TaxTotal = Add(CustLaborTaxTotal, CustPartTaxTotal);
+        if (detailedInfo) {
+            argRecordData.FixedSubTotal = TrUtils.FixedTo(CustomerAfterDiscTotals, DecimalsNumber);
+            argRecordData.FixedTotal = TrUtils.FixedTo(CustTotal, DecimalsNumber);
+        }
+
+        if (isRoundable) {
+            argRecordData.Round = Subtract(Math.round(CustTotal), CustTotal);
+            argRecordData.Total = Math.round(CustTotal);
+        } else {
+            argRecordData.Total = TrUtils.FixedTo(CustTotal, DecimalsNumber);
+        }
+
+
+
+        return argRecordData;
+    }
+
+    static GetCustSubTotal(LaborList: any, PartsList: any) {
+        let LaborTotalAfterDisc: any = this.GetCustLaborTotalAfterDiscount(LaborList);
+        let PartsTotalAfterDisc: any = this.GetCustPartsTotalAfterDiscount(PartsList);
+        return Add(LaborTotalAfterDisc, PartsTotalAfterDisc);
+    }
+
+    static GetCustLaborTotalAfterDiscount(LaborList: any) {
+        let LaborTotalAfterDisc: any = 0;
+        LaborList.forEach((Labor: any) => {
+            LaborTotalAfterDisc = Add(LaborTotalAfterDisc, Labor.CustAfterLaborDisc);
+        });
+        return LaborTotalAfterDisc;
+    }
+
+    static GetCustPartsTotalAfterDiscount(PartsList: any) {
+        let PartsTotalAfterDisc: any = 0;
+        PartsList.forEach((Part: any) => {
+            PartsTotalAfterDisc = Add(PartsTotalAfterDisc, Part.CustAfterPartDisc);
+        });
+        return PartsTotalAfterDisc;
+    }
+
+    static GetCustLaborTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor: any) => {
+                if (isWorkOrder) {
+                    // if (Labor.PBy === PayTypeEnum.Customer) {
+                    if ((Labor.PBy === PayTypeEnum.Customer || Labor.PBy === PayTypeEnum.Shared)) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Labor.CCGST, Labor.CSGST, Labor.CIGST);
+                    }
+                    // }else{
+                    //     TotalTaxAmt = Add(TotalTaxAmt , Labor.ACGST , Labor.ASGST , Labor.AIGST);
+                    // }
+                } else {
+                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Labor.CCGST, Labor.CSGST, Labor.CIGST);
+                    } else {
+                        if (Labor.PBy === PayTypeEnum.Customer) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Labor.ECGST, Labor.ESGST, Labor.EIGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetCustPartsTaxTotal(OpsList: any, PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part: any) => {
+                if (!TrUtils.IsNull(Part.CollId)) {
+                    if (isWorkOrder) {
+                        if ((Part.PBy === PayTypeEnum.Customer || Part.PBy === PayTypeEnum.Shared)) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
+                        }
+                    } else {
+                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
+                        } else {
+                            if (Part.PBy === PayTypeEnum.Customer) {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.ECGST, Part.ESGST, Part.EIGST);
+                            }
+                        }
+                    }
+                } else {
+                    if (isWorkOrder) {
+                        // if (Part.PBy === PayTypeEnum.Customer) {
+                        if ((Part.PBy === PayTypeEnum.Customer || Part.PBy === PayTypeEnum.Shared)) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
+                        }
+                        // }else{
+                        //         TotalTaxAmt = Add(TotalTaxAmt , Part.ACGST , Part.ASGST , Part.AIGST);
+                        //     }
+                    } else {
+                        let Index: any = OpsList.findIndex((labor: any) => {
+                            return labor._id === Part.OpId;
+                        });
+                        if (Index !== -1) {
+                            if (OpsList[Index].Sts !== LaborStatusEnum.New && OpsList[Index].Sts !== LaborStatusEnum.WtngForAppr) {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
+                            } else {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.ECGST, Part.ESGST, Part.EIGST);
+                            }
+                        } else {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetCustomerTotalBasedOnTaxType(dupRecordData: any, LaborTaxAmount: number, PartsTaxAmount: number, LaborList: any, PartsList: any, IsTaxable: boolean) {
+
+        let SubTotalWithTax: any = 0;
+        let LaborTotalAfterDisc: any = this.GetCustLaborTotalAfterDiscount(LaborList);
+        let PartsTotalAfterDisc: any = this.GetCustPartsTotalAfterDiscount(PartsList);
+
+        if (IsTaxable) {
+            SubTotalWithTax = Add(LaborTotalAfterDisc, PartsTotalAfterDisc, LaborTaxAmount, PartsTaxAmount);
+        } else {
+            SubTotalWithTax = Add(LaborTotalAfterDisc, PartsTotalAfterDisc);
+        }
+
+        return SubTotalWithTax;
+    }
+
+    static GetFinalInsuranceTotalsData(argRecordData: any, dupRecordData: any, detailedInfo: boolean, isWorkOrder: boolean, DecimalsNumber: number) {
+        let InsuranceAfterDiscTotals: number = this.GetInsSubTotal(dupRecordData.Ops, dupRecordData.Parts);
+
+        let InsLaborTaxTotal = this.GetInsLaborTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+
+        let InsPartTaxTotal = this.GetInsPartsTaxTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+
+        let InsTotal: any = this.GetInsuranceTotalBasedOnTaxType(InsuranceAfterDiscTotals, InsLaborTaxTotal, InsPartTaxTotal,
+            TrUtils.isTaxable(dupRecordData.Settings.Tax));
+
+        argRecordData.InsTaxTotal = Add(InsLaborTaxTotal, InsPartTaxTotal);
+        argRecordData.InsTotal = TrUtils.FixedTo(InsTotal, DecimalsNumber);
+
+        if (detailedInfo) {
+            argRecordData.FixedInsTotal = TrUtils.FixedTo(InsTotal, DecimalsNumber);
+        }
+
+        return argRecordData;
+    }
+
+    static GetInsSubTotal(LaborList: any, PartsList: any) {
+        let LaborTotalAfterDisc: any = this.GetInsLaborTotalAfterDiscount(LaborList);
+        let PartsTotalAfterDisc: any = this.GetInsPartsTotalAfterDiscount(PartsList);
+        return Add(LaborTotalAfterDisc, PartsTotalAfterDisc);
+    }
+
+    static GetInsLaborTotalAfterDiscount(LaborList: any) {
+        let LaborTotalAfterDisc: any = 0;
+        LaborList.forEach((Labor: any) => {
+            LaborTotalAfterDisc = Add(LaborTotalAfterDisc, Labor.InsAfterLaborDisc);
+        });
+        return LaborTotalAfterDisc;
+    }
+
+    static GetInsPartsTotalAfterDiscount(PartsList: any) {
+        let PartsTotalAfterDisc: any = 0;
+        PartsList.forEach((Part: any) => {
+            PartsTotalAfterDisc = Add(PartsTotalAfterDisc, Part.InsAfterPartDisc);
+        });
+        return PartsTotalAfterDisc;
+    }
+
+    static GetInsLaborTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor: any) => {
+                if (isWorkOrder) {
+                    if ((Labor.PBy === PayTypeEnum.Insurance || Labor.PBy === PayTypeEnum.Shared)) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Labor.ACGST, Labor.ASGST, Labor.AIGST);
+                    }
+                } else {
+                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Labor.ACGST, Labor.ASGST, Labor.AIGST);
+                    } else {
+                        if (Labor.PBy === PayTypeEnum.Insurance || Labor.PBy === PayTypeEnum.Shared) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Labor.ECGST, Labor.ESGST, Labor.EIGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetInsPartsTaxTotal(PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part: any) => {
+                if (!TrUtils.IsNull(Part.CollId) || Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
+                    if (isWorkOrder) {
+                        if ((Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared)) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.ACGST, Part.ASGST, Part.AIGST);
+                        }
+                    } else {
+                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.ACGST, Part.ASGST, Part.AIGST);
+                        } else {
+                            if (Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.ECGST, Part.ESGST, Part.EIGST);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetInsuranceTotalBasedOnTaxType(SubTotal: number, LaborTaxAmount: number, PartsTaxAmount: number, IsTaxable: boolean) {
+        let InsTotal: any = 0;
+        if (IsTaxable) {
+            InsTotal = Add(SubTotal, LaborTaxAmount, PartsTaxAmount);
+        } else {
+            InsTotal = (SubTotal);
+        }
+        return InsTotal;
+    }
+
+    static GetDetailedTotalsData(argRecordData: any, dupRecordData: any, TaxCodes: any, isWorkOrder: boolean, DecimalsNumber: number) {
+        argRecordData.InsLaborDiscTotal = 0;
+        argRecordData.InsPartsDiscTotal = 0;
+
+        argRecordData.InsLaborTotalAfterDisc = this.GetInsLaborTotalAfterDiscount(dupRecordData.Ops);
+        argRecordData.InsPartsTotalAfterDisc = this.GetInsPartsTotalAfterDiscount(dupRecordData.Parts);
+
+        argRecordData.InsLaborTotalBeforeDisc = Add(argRecordData.InsLaborTotalAfterDisc
+            , argRecordData.InsLaborDiscTotal);
+        argRecordData.InsPartsTotalBeforeDisc = Add(argRecordData.InsPartsTotalAfterDisc
+            , argRecordData.InsPartsDiscTotal);
+
+        argRecordData.InsLaborITax = this.GetInsLaborTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsLaborCGST = this.GetInsLaborCGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsLaborIGST = this.GetInsLaborIGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsLaborSGST = this.GetInsLaborSGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+
+        argRecordData.InsPartITax = this.GetInsPartsTaxTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsPartCGST = this.GetInsPartCGSTTaxTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsPartIGST = this.GetInsPartIGSTTaxTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.InsPartSGST = this.GetInsPartSGSTTaxTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+
+        argRecordData.InsLaborTotalAfterTax = Add(argRecordData.InsLaborTotalAfterDisc,
+            argRecordData.InsLaborITax);
+        argRecordData.InsPartsTotalAfterTax = Add(argRecordData.InsPartsTotalAfterDisc,
+            argRecordData.InsPartITax);
+
+        argRecordData.CustLaborDiscTotal = this.GetCustLaborDiscountedTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);
+        argRecordData.CustPartsDiscTotal = this.GetCustPartDiscountedTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);
+
+        argRecordData.CustLaborTotalAfterDisc = this.GetCustLaborTotalAfterDiscount(dupRecordData.Ops);
+        argRecordData.CustPartsTotalAfterDisc = this.GetCustPartsTotalAfterDiscount(dupRecordData.Parts);
+
+        argRecordData.CustLaborTotalBeforeDisc = Add(argRecordData.CustLaborTotalAfterDisc
+            , argRecordData.CustLaborDiscTotal);
+        argRecordData.CustPartsTotalBeforeDisc = Add(argRecordData.CustPartsTotalAfterDisc
+            , argRecordData.CustPartsDiscTotal);
+
+        argRecordData.CustLaborITax = this.GetCustLaborTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustLaborSGST = this.GetCustLaborSGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustLaborCGST = this.GetCustLaborCGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustLaborIGST = this.GetCustLaborIGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+
+        argRecordData.CustPartITax = this.GetCustPartsTaxTotal(dupRecordData.Ops, dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustPartCGST = this.GetCustPartCGSTTaxTotal(dupRecordData.Ops, dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustPartIGST = this.GetCustPartIGSTTaxTotal(dupRecordData.Ops, dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
+        argRecordData.CustPartSGST = this.GetCustPartSGSTTaxTotal(dupRecordData.Ops, dupRecordData.Parts, 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 = Add(argRecordData.CustLaborITax, argRecordData.CustLaborAfterLDisc);
+        argRecordData.CustPartAfterTax = Add(argRecordData.CustPartITax, argRecordData.CustPartsAfterPDisc);
+
+        argRecordData.CustTaxGroupData = this.GetCustPartsTaxGrouping(dupRecordData.Parts, TaxCodes, isWorkOrder, DecimalsNumber);
+        argRecordData.InsTaxGroupData = this.GetInsPartsTaxGrouping(dupRecordData.Parts, TaxCodes, DecimalsNumber);
+
+        argRecordData.CustTotalRoundedBy = argRecordData.Round;
+        argRecordData.InsTotalRoundedBy = TrUtils.FixedTo(Subtract(Math.round(argRecordData.InsTotal), argRecordData.InsTotal), DecimalsNumber);
+
+        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] = TrUtils.FixPriceValue(argRecordData[key], DecimalsNumber);
+            }
+        }
+
+        return argRecordData;
+    }
+
+    static GetCustLaborDiscountedTotal(LaborList: any, isTaxable: boolean, finalTotalsData: any) {
+        let LaborDiscountedTotal: any = 0;
+        let overallLaborDisc: number = 0;
+        if (!isTaxable) {
+            overallLaborDisc = TrUtils.SetValueToZeroIfNull(finalTotalsData.LDisc)
+        }
+        LaborList.forEach((Labor: any) => {
+            LaborDiscountedTotal = Add(LaborDiscountedTotal, Labor.CustDiscountedPrice);
+        });
+        return Add(LaborDiscountedTotal, overallLaborDisc);
+    }
+
+    static GetCustPartDiscountedTotal(PartsList: any, isTaxable: boolean, finalTotalsData: any) {
+        let PartsDiscountedTotal: any = 0;
+        let overallPartDisc: number = 0;
+        if (!isTaxable) {
+            overallPartDisc = TrUtils.SetValueToZeroIfNull(finalTotalsData.PDisc)
+        }
+        PartsList.forEach((Part: any) => {
+            PartsDiscountedTotal = Add(PartsDiscountedTotal, Part.CustDiscountedPrice);
+        });
+        return Add(PartsDiscountedTotal, overallPartDisc);
+    }
+
+    static GetCustLaborCGSTTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor: any) => {
+                if (isWorkOrder) {
+                    TotalTaxAmt = Add(TotalTaxAmt, Labor.CCGST);
+                } else {
+                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Labor.CCGST);
+                    } else {
+                        if (Labor.PBy === PayTypeEnum.Customer) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Labor.ECGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetCustLaborIGSTTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor: any) => {
+                if (isWorkOrder) {
+                    TotalTaxAmt = Add(TotalTaxAmt, Labor.CIGST);
+                } else {
+                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Labor.CIGST);
+                    } else {
+                        if (Labor.PBy === PayTypeEnum.Customer) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Labor.EIGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetCustLaborSGSTTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor: any) => {
+                if (isWorkOrder) {
+                    TotalTaxAmt = Add(TotalTaxAmt, Labor.CSGST);
+                } else {
+                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Labor.CSGST);
+                    } else {
+                        if (Labor.PBy === PayTypeEnum.Customer) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Labor.ESGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetCustPartCGSTTaxTotal(OpsList: any, PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part: any) => {
+                if (!TrUtils.IsNull(Part.CollId)) {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST);
+                    } else {
+                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST);
+                        } else {
+                            if (Part.PBy === PayTypeEnum.Customer) {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.ECGST);
+                            }
+                        }
+                    }
+                } else {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST);
+                    } else {
+                        let Index: any = OpsList.findIndex((labor: any) => {
+                            return labor._id === Part.OpId;
+                        });
+                        if (Index !== -1) {
+                            if (OpsList[Index].Sts !== LaborStatusEnum.New && OpsList[Index].Sts !== LaborStatusEnum.WtngForAppr) {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST);
+                            } else {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.ECGST);
+                            }
+                        } else {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetCustPartIGSTTaxTotal(OpsList: any, PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part: any) => {
+                if (!TrUtils.IsNull(Part.CollId)) {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Part.CIGST);
+                    } else {
+                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.CIGST);
+                        } else {
+                            if (Part.PBy === PayTypeEnum.Customer) {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.EIGST);
+                            }
+                        }
+                    }
+                } else {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Part.CIGST);
+                    } else {
+                        let Index: any = OpsList.findIndex((labor: any) => {
+                            return labor._id === Part.OpId;
+                        });
+                        if (Index !== -1) {
+                            if (OpsList[Index].Sts !== LaborStatusEnum.New && OpsList[Index].Sts !== LaborStatusEnum.WtngForAppr) {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.CIGST);
+                            } else {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.EIGST);
+                            }
+                        } else {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.CIGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetCustPartSGSTTaxTotal(OpsList: any, PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part: any) => {
+                if (!TrUtils.IsNull(Part.CollId)) {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Part.CSGST);
+                    } else {
+                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.CSGST);
+                        } else {
+                            if (Part.PBy === PayTypeEnum.Customer) {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.ESGST);
+                            }
+                        }
+                    }
+                } else {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Part.CSGST);
+                    } else {
+                        let Index: any = OpsList.findIndex((labor: any) => {
+                            return labor._id === Part.OpId;
+                        });
+                        if (Index !== -1) {
+                            if (OpsList[Index].Sts !== LaborStatusEnum.New && OpsList[Index].Sts !== LaborStatusEnum.WtngForAppr) {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.CSGST);
+                            } else {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.ESGST);
+                            }
+                        } else {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.CSGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetInsLaborCGSTTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor: any) => {
+                if (isWorkOrder) {
+                    TotalTaxAmt = Add(TotalTaxAmt, Labor.ACGST);
+                } else {
+                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Labor.ACGST);
+                    } else {
+                        if (Labor.PBy === PayTypeEnum.Insurance || Labor.PBy === PayTypeEnum.Shared) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Labor.ECGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetInsLaborIGSTTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor: any) => {
+                if (isWorkOrder) {
+                    TotalTaxAmt = Add(TotalTaxAmt, Labor.AIGST);
+                } else {
+                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Labor.AIGST);
+                    } else {
+                        if (Labor.PBy === PayTypeEnum.Insurance || Labor.PBy === PayTypeEnum.Shared) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Labor.EIGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetInsLaborSGSTTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor: any) => {
+                if (isWorkOrder) {
+                    TotalTaxAmt = Add(TotalTaxAmt, Labor.ASGST);
+                } else {
+                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Labor.ASGST);
+                    } else {
+                        if (Labor.PBy === PayTypeEnum.Insurance || Labor.PBy === PayTypeEnum.Shared) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Labor.ESGST);
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetInsPartCGSTTaxTotal(PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part: any) => {
+                if (!TrUtils.IsNull(Part.CollId) || Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Part.ACGST);
+                    } else {
+                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.ACGST);
+                        } else {
+                            if (Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.ECGST);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetInsPartIGSTTaxTotal(PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part: any) => {
+                if (!TrUtils.IsNull(Part.CollId) || Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Part.AIGST);
+                    } else {
+                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.AIGST);
+                        } else {
+                            if (Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.EIGST);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetInsPartSGSTTaxTotal(PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            PartsList.forEach((Part: any) => {
+                if (!TrUtils.IsNull(Part.CollId) || Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
+                    if (isWorkOrder) {
+                        TotalTaxAmt = Add(TotalTaxAmt, Part.ASGST);
+                    } else {
+                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
+                            TotalTaxAmt = Add(TotalTaxAmt, Part.ASGST);
+                        } else {
+                            if (Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
+                                TotalTaxAmt = Add(TotalTaxAmt, Part.ESGST);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetLaborLDiscAmount(LaborTotalAfterDisc: any, LDisc: any) {
+        let LaborLDiscAmt: any = 0;
+
+        if (!TrUtils.IsZero(LaborTotalAfterDisc)) {
+            LaborLDiscAmt = LDisc;
+        }
+        return LaborLDiscAmt;
+    }
+
+    static GetPartsPDiscAmount(PartsTotalAfterDisc: any, PDisc: any) {
+        let PartsPDiscAmt: any = 0;
+
+        if (!TrUtils.IsZero(PartsTotalAfterDisc)) {
+            PartsPDiscAmt = PDisc;
+        }
+
+        return PartsPDiscAmt;
+    }
+
+    static GetCustPartsTaxGrouping(PartsList: any, TaxCodes: any, isWorkOrder: boolean, DecimalsNumber: number) {
+        let FilteredPartsList = this.GetCustParts(PartsList);
+        return this.GetCustTaxGroupingForPartsByHSN(FilteredPartsList, TaxCodes, isWorkOrder, DecimalsNumber);
+    }
+
+    static GetCustParts(PartsList: any) {
+        let FilteredPartsList: any[] = PartsList.filter((Part: any) => {
+            return Part.PBy === PayTypeEnum.Customer || Part.PBy === PayTypeEnum.Shared;
+        });
+        return FilteredPartsList;
+    }
+
+    static GetCustTaxGroupingForPartsByHSN(Parts: any, TaxCodes: any, isWorkOrder: boolean, DecimalsNumber: number) {
+        Parts = this.GetCombinedTaxPercentage(Parts, TaxCodes);
+        Parts = this.ResetPartsHSNIfInvalid(Parts);
+
+        let FinalMatchedParts: any[] = this.ComparePartsByHSN(Parts, TaxCodes);
+
+        return this.GetCustTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes, isWorkOrder, DecimalsNumber);
+    }
+
+    static GetCustTaxGroupingInfoByHSN(FinalMatchedParts: any, TaxCodes: any, isWorkOrder: boolean, DecimalsNumber: number) {
+        let HSNTaxInfo: any[] = [];
+        FinalMatchedParts.forEach((MatchedPart: any) => {
+            let TaxInfo: any = {};
+            let TaxOnAmount: any = 0;
+            let TaxAmount: any = 0;
+            let HSN: any = MatchedPart[0].HSN;
+            TaxInfo.CombinedTaxPercentage = MatchedPart[0].CombinedTaxPercentage;
+            MatchedPart.forEach((argMatchedGSTPart: any) => {
+                TaxOnAmount = Add(TaxOnAmount, TrUtils.FixedTo(argMatchedGSTPart.CustAfterPartDisc, DecimalsNumber));
+                if (isWorkOrder) {
+                    TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.CCGST, DecimalsNumber));
+                    TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.CIGST, DecimalsNumber));
+                    TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.CSGST, DecimalsNumber));
+                } else {
+                    if (argMatchedGSTPart.Sts !== LaborStatusEnum.New && argMatchedGSTPart.Sts !== LaborStatusEnum.WtngForAppr) {
+                        TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.CCGST, DecimalsNumber));
+                        TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.CIGST, DecimalsNumber));
+                        TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.CSGST, DecimalsNumber));
+                    } else {
+                        if (argMatchedGSTPart.PBy === PayTypeEnum.Customer) {
+                            TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.ECGST, DecimalsNumber));
+                            TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.EIGST, DecimalsNumber));
+                            TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.ESGST, DecimalsNumber));
+                        }
+                    }
+                }
+            });
+            TaxInfo.HSN = HSN;
+            TaxInfo.TotalTaxableAmount = TrUtils.FixPriceValue(TaxOnAmount, DecimalsNumber);
+            TaxInfo.TotalTaxAmount = TrUtils.FixPriceValue(TaxAmount, DecimalsNumber);
+            TaxInfo.PartsCount = MatchedPart.length;
+            let GSTValues: any[] = this.GetGSTValueBasedOnTaxCode(MatchedPart[0], TaxCodes);
+            TaxInfo.CGST = GSTValues[0];
+            TaxInfo.SGST = GSTValues[1];
+            TaxInfo.IGST = GSTValues[2];
+            if (TaxOnAmount !== 0) {
+                HSNTaxInfo.push(TaxInfo);
+            }
+        });
+        return HSNTaxInfo;
+    }
+
+    static GetInsPartsTaxGrouping(PartsList: any, TaxCodes: any, DecimalsNumber: number) {
+        let FilteredPartsList = this.GetInsParts(PartsList);
+        return this.GetInsTaxGroupingForPartsByHSN(FilteredPartsList, TaxCodes, DecimalsNumber);
+    }
+
+    static GetInsParts(PartsList: any) {
+        let FilteredPartsList: any[] = PartsList.filter((Part: any) => {
+            return Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared;
+        });
+        return FilteredPartsList;
+    }
+
+    static GetInsTaxGroupingForPartsByHSN(Parts: any, TaxCodes: any, DecimalsNumber: number) {
+        Parts = this.GetCombinedTaxPercentage(Parts, TaxCodes);
+        Parts = this.ResetPartsHSNIfInvalid(Parts);
+
+        let FinalMatchedParts: any[] = this.ComparePartsByHSN(Parts, TaxCodes);
+
+        return this.GetInsTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes, DecimalsNumber);
+    }
+
+    static GetInsTaxGroupingInfoByHSN(FinalMatchedParts: any, TaxCodes: any, DecimalsNumber: number) {
+        let HSNTaxInfo: any[] = [];
+        FinalMatchedParts.forEach((MatchedPart: any) => {
+            let TaxInfo: any = {};
+            let TaxOnAmount: any = 0;
+            let TaxAmount: any = 0;
+            let HSN: any = MatchedPart[0].HSN;
+            TaxInfo.CombinedTaxPercentage = MatchedPart[0].CombinedTaxPercentage;
+            MatchedPart.forEach((argMatchedGSTPart: any) => {
+                TaxOnAmount = Add(TaxOnAmount, TrUtils.FixedTo(argMatchedGSTPart.InsAfterPartDisc, DecimalsNumber));
+                if (argMatchedGSTPart.PBy === PayTypeEnum.Insurance || argMatchedGSTPart.PBy === PayTypeEnum.Shared) {
+                    if (argMatchedGSTPart.Sts !== LaborStatusEnum.New && argMatchedGSTPart.Sts !== LaborStatusEnum.WtngForAppr) {
+                        TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.ACGST, DecimalsNumber));
+                        TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.AIGST, DecimalsNumber));
+                        TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.ASGST, DecimalsNumber));
+                    } else {
+                        TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.ECGST, DecimalsNumber));
+                        TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.EIGST, DecimalsNumber));
+                        TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.ESGST, DecimalsNumber));
+                    }
+                }
+            });
+            TaxInfo.HSN = HSN;
+            TaxInfo.TotalTaxableAmount = TrUtils.FixPriceValue(TaxOnAmount, DecimalsNumber);
+            TaxInfo.TotalTaxAmount = TrUtils.FixPriceValue(TaxAmount, DecimalsNumber);
+            TaxInfo.PartsCount = MatchedPart.length;
+            let GSTValues: any[] = this.GetGSTValueBasedOnTaxCode(MatchedPart[0], TaxCodes);
+            TaxInfo.CGST = GSTValues[0];
+            TaxInfo.SGST = GSTValues[1];
+            TaxInfo.IGST = GSTValues[2];
+            if (TaxOnAmount !== 0) {
+                HSNTaxInfo.push(TaxInfo);
+            }
+        });
+        return HSNTaxInfo;
+    }
+
+    static GetGSTValueBasedOnTaxCode(item: any, TaxCodes: any) {
+        let CGST: number = 0;
+        let SGST: number = 0;
+        let IGST: number = 0;
+        const taxGroupKeys: string[] = ['Taxes', 'CTaxes', 'ATaxes', 'ETaxes'];
+
+        for (const taxGroupKey of taxGroupKeys) {
+            const groupedTaxes = item?.[taxGroupKey];
+            if (!Array.isArray(groupedTaxes) || groupedTaxes.length === 0) {
+                continue;
+            }
+
+            CGST = groupedTaxes
+                .filter((tax: any) => tax?.Code === 'CGST')
+                .reduce((total: number, tax: any) => Add(total, tax?.Rate), 0);
+            SGST = groupedTaxes
+                .filter((tax: any) => tax?.Code === 'SGST')
+                .reduce((total: number, tax: any) => Add(total, tax?.Rate), 0);
+            IGST = groupedTaxes
+                .filter((tax: any) => tax?.Code === 'IGST')
+                .reduce((total: number, tax: any) => Add(total, tax?.Rate), 0);
+
+            if (!TrUtils.IsZero(Add(CGST, SGST, IGST))) {
+                return [CGST, SGST, IGST];
+            }
+        }
+
+        const TCode = item?.TCode;
+        if (TrUtils.IsNull(TCode)) {
+            return [CGST, SGST, IGST];
+        }
+        let TCodeIndex: any = TaxCodes.findIndex((TaxCode: any) => {
+            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: any, TaxCodes: any) {
+        Parts.forEach((Part: any) => {
+            let GSTValues: any[] = this.GetGSTValueBasedOnTaxCode(Part, TaxCodes);
+            let CGST = GSTValues[0];
+            let SGST = GSTValues[1];
+            let IGST = GSTValues[2];
+
+            Part.CombinedTaxPercentage = Add(CGST, SGST, IGST);
+        });
+        return Parts;
+    }
+
+    static ResetPartsHSNIfInvalid(Parts: any) {
+        Parts.forEach((Part: any) => {
+            if (TrUtils.IsNull(Part.HSN)) {
+                Part.HSN = '';
+            }
+        });
+        return Parts;
+    }
+
+    static ComparePartsByHSN(Parts: any, TaxCodes: any) {
+        let FinalMatchedParts: any[] = [];
+        Parts.forEach((Part: any) => {
+            let MatchedPartsBasedOnHSN = Parts.filter((argPart: any) => {
+                let PartFound: boolean = false;
+                FinalMatchedParts.forEach((FinalArgParts: any) => {
+                    let PartIndex: any = FinalArgParts.findIndex((FinalArgPart: any) => {
+                        return FinalArgPart._id === argPart._id;
+                    });
+                    if (PartIndex !== -1) {
+                        PartFound = true;
+                    }
+                });
+
+                let argGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(argPart, TaxCodes);
+                let argCGST = argGSTValues[0];
+                let argSGST = argGSTValues[1];
+                let argIGST = argGSTValues[2];
+
+                let partGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(Part, 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;
+    }
+
+}