shareneus 1.0.5

package/dist/services/invoice-total.service.js

@@ -0,0 +1,659 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvoiceTotalsService = void 0;
+const aggregation_1 = require("../aggregation/aggregation");
+const tr_utils_1 = require("../utils/tr-utils");
+class InvoiceTotalsService {
+    static GetTotalsValue(opCodesList, PartsList, IsIndependentTax, DetailedInfo, LDisc, LPerc, PDisc, PPerc, Disc, Perc, TaxCodes, WithItems, Settings, Adjust, isRoundable) {
+        LPerc = tr_utils_1.TrUtils.SetPercToStringIfNull(LPerc);
+        PPerc = tr_utils_1.TrUtils.SetPercToStringIfNull(PPerc);
+        Perc = tr_utils_1.TrUtils.SetPercToStringIfNull(Perc);
+        LDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(LDisc);
+        PDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(PDisc);
+        Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Disc);
+        if (tr_utils_1.TrUtils.IsNull(opCodesList)) {
+            opCodesList = [];
+        }
+        if (tr_utils_1.TrUtils.IsNull(PartsList)) {
+            PartsList = [];
+        }
+        opCodesList = this.CalculateLaborValues(opCodesList, IsIndependentTax);
+        PartsList = this.CalculateLaborPartValues(PartsList, IsIndependentTax);
+        let finalTotalsData = this.GetFinalRODataForSave(opCodesList, PartsList, IsIndependentTax, LDisc, LPerc, PDisc, PPerc, Disc, Perc, DetailedInfo, Settings, tr_utils_1.TrUtils.SetValueToZeroIfNull(Adjust), isRoundable);
+        if (DetailedInfo) {
+            finalTotalsData = this.GetDetailedTotalsData(finalTotalsData, IsIndependentTax, opCodesList, PartsList, TaxCodes);
+        }
+        if (WithItems) {
+            finalTotalsData.Ops = opCodesList;
+            finalTotalsData.Items = PartsList;
+        }
+        return finalTotalsData;
+    }
+    static CalculateLaborValues(opCodesList, IsIndependentTax) {
+        opCodesList = this.ResetLaborValues(opCodesList, IsIndependentTax);
+        // opCodesList = this.GetOperationsDiscountPrice(opCodesList);
+        // opCodesList = this.GetOperationsAfterDiscount(opCodesList,IsIndependentTax);
+        // opCodesList = this.GetOperationsAfterTax(opCodesList, IsIndependentTax);
+        return opCodesList;
+    }
+    static ResetLaborValues(opCodesList, IsIndependentTax) {
+        opCodesList.forEach((Operation) => {
+            Operation = this.ResetLaborValueIfInvalid(Operation);
+            Operation.DiscountedPrice = (0, aggregation_1.addition)(Operation.Disc, Operation.RecDisc);
+            if (tr_utils_1.TrUtils.IsNull(Operation.Amt)) {
+                Operation.Amt = Operation.Pr;
+            }
+            if (IsIndependentTax) {
+                Operation.AfterLaborDisc = Operation.NetAmt;
+                Operation.AfterLaborTax = (0, aggregation_1.addition)(Operation.AfterLaborDisc, Operation.CGST, Operation.SGST, Operation.IGST);
+            }
+            else {
+                Operation.AfterLaborDisc = (0, aggregation_1.subtraction)(Operation.Amt, Operation.Disc);
+                Operation.AfterLaborTax = Operation.AfterLaborDisc;
+            }
+        });
+        return opCodesList;
+    }
+    static ResetLaborValueIfInvalid(Operation) {
+        Operation.Pr = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.Pr);
+        Operation.RecDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.RecDisc);
+        Operation.Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.Disc);
+        Operation.CGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.CGST);
+        Operation.SGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.SGST);
+        Operation.IGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.IGST);
+        return Operation;
+    }
+    static CalculateLaborPartValues(PartsList, IsIndependentTax) {
+        PartsList = this.ResetLaborPartValues(PartsList, IsIndependentTax);
+        // PartsList = this.GetLaborPartsDiscountPrice(PartsList);
+        // PartsList = this.GetLaborPartsAfterDiscount(PartsList,IsIndependentTax);
+        // PartsList = this.GetPartsAfterTax(PartsList, IsIndependentTax);
+        return PartsList;
+    }
+    static ResetLaborPartValues(PartsList, IsIndependentTax) {
+        PartsList.forEach((Part) => {
+            Part = this.ResetLaborPartValueIfInvalid(Part);
+            Part.DiscountedPrice = (0, aggregation_1.addition)(Part.Disc, Part.RecDisc);
+            if (IsIndependentTax) {
+                Part.AfterPartDisc = Part.NetAmt;
+                Part.AfterPartTax = (0, aggregation_1.addition)(Part.AfterPartDisc, Part.CGST, Part.SGST, Part.IGST);
+            }
+            else {
+                Part.AfterPartDisc = (0, aggregation_1.subtraction)(Part.UnAmt, Part.Disc);
+                Part.AfterPartTax = Part.AfterPartDisc;
+            }
+        });
+        return PartsList;
+    }
+    static ResetLaborPartValueIfInvalid(Part) {
+        Part.UnPr = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.UnPr);
+        Part.Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.Disc);
+        Part.RecDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.RecDisc);
+        Part.CGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.CGST);
+        Part.SGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.SGST);
+        Part.IGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.IGST);
+        return Part;
+    }
+    static GetFinalRODataForSave(LaborList, PartsList, IsIndependentTax, LDisc, LPerc, PDisc, PPerc, Disc, Perc, DetailedInfo, Settings, Adjust, isRoundable) {
+        let finalTotalsData = {};
+        finalTotalsData = this.SetMainDiscountValues(LPerc, PPerc, LDisc, PDisc, Disc, Perc, finalTotalsData, DetailedInfo);
+        finalTotalsData.Settings = Settings;
+        finalTotalsData = this.GetFinalCustomerTotalsData(finalTotalsData, LaborList, PartsList, IsIndependentTax, DetailedInfo, Adjust, isRoundable);
+        return finalTotalsData;
+    }
+    static SetMainDiscountValues(LPerc, PPerc, LDisc, PDisc, Disc, Perc, finalTotalsData, DetailedInfo) {
+        finalTotalsData.LDisc = LDisc;
+        finalTotalsData.LPerc = LPerc;
+        finalTotalsData.PDisc = PDisc;
+        finalTotalsData.PPerc = PPerc;
+        finalTotalsData.Disc = Disc;
+        finalTotalsData.Perc = Perc;
+        if (DetailedInfo) {
+            finalTotalsData.FixedLDisc = LDisc;
+            finalTotalsData.FixedPDisc = PDisc;
+            finalTotalsData.FixedDisc = Disc;
+        }
+        return finalTotalsData;
+    }
+    static GetPartsAfterDiscount1(PartsList) {
+        let AfterIndvidualDisc = 0;
+        PartsList.forEach((Part) => {
+            if (!Part.Ret) {
+                AfterIndvidualDisc = (0, aggregation_1.addition)(AfterIndvidualDisc, (0, aggregation_1.subtraction)(Part.UnAmt, Part.Disc));
+            }
+        });
+        return AfterIndvidualDisc;
+    }
+    static GetLaborTotalAfterDiscount1(OperationsList) {
+        let AfterIndvidualDisc = 0;
+        OperationsList.forEach((Operation) => {
+            if (tr_utils_1.TrUtils.IsNull(Operation.Amt)) {
+                Operation.Amt = Operation.Pr;
+            }
+            AfterIndvidualDisc = (0, aggregation_1.addition)(AfterIndvidualDisc, (0, aggregation_1.subtraction)(Operation.Amt, Operation.Disc));
+        });
+        return AfterIndvidualDisc;
+    }
+    static GetFinalCustomerTotalsData(finalTotalsData, LaborList, PartsList, IsIndependentTax, DetailedInfo, Adjust, isRoundable) {
+        let CustomerAfterDiscTotals = this.GetSubTotalFor(LaborList, PartsList);
+        let CustLaborTaxTotal = this.GetLaborTaxTotalFor(LaborList, IsIndependentTax);
+        let CustPartTaxTotal = this.GetPartsTaxTotalFor(PartsList, IsIndependentTax);
+        let RetCustParrtTaxTotal = this.GetRetPartsTaxTotalFor(PartsList, IsIndependentTax);
+        let NonRetCustParrtTaxTotal = this.GetNonRetPartsTaxTotalFor(PartsList, IsIndependentTax);
+        finalTotalsData.SubTotal = tr_utils_1.TrUtils.FixedTo(CustomerAfterDiscTotals);
+        let CustLaborDiscTotal = this.GetLaborDiscountedTotal(LaborList, IsIndependentTax, finalTotalsData);
+        let CustPartsDiscTotal = this.GetPartDiscountedTotal(PartsList, IsIndependentTax, finalTotalsData);
+        let CustLaborTotalAfterDisc = this.GetLaborTotalAfterDiscount(LaborList);
+        let CustPartsTotalAfterDisc = this.GetPartsTotalAfterDiscount(PartsList);
+        if (IsIndependentTax) {
+            finalTotalsData.STotal = (0, aggregation_1.addition)(CustLaborDiscTotal, CustPartsDiscTotal, CustLaborTotalAfterDisc, CustPartsTotalAfterDisc);
+        }
+        else {
+            finalTotalsData.STotal = (0, aggregation_1.addition)(CustLaborTotalAfterDisc, CustPartsTotalAfterDisc);
+        }
+        let CustLaborTotalAfterDisc1 = this.GetLaborTotalAfterDiscount1(LaborList);
+        let CustPartsTotalAfterDisc1 = this.GetPartsAfterDiscount1(PartsList);
+        let AmtAfterIndvidualItemDisc = (0, aggregation_1.addition)(CustLaborTotalAfterDisc1, CustPartsTotalAfterDisc1);
+        finalTotalsData.SIndTotal = AmtAfterIndvidualItemDisc;
+        finalTotalsData.Disc = !tr_utils_1.TrUtils.IsEmpty(finalTotalsData.Perc) ? tr_utils_1.TrUtils.ConvertPercToVal(finalTotalsData.Perc, AmtAfterIndvidualItemDisc) : finalTotalsData.Disc;
+        let CustTotal = this.GetCustomerTotalBasedOnTaxType(finalTotalsData, CustLaborTaxTotal, CustPartTaxTotal, LaborList, PartsList, IsIndependentTax, Adjust);
+        let RetCustTotal = this.GetRetCustomerTotalBasedOnTaxType(finalTotalsData, CustLaborTaxTotal, RetCustParrtTaxTotal, LaborList, PartsList, IsIndependentTax, Adjust);
+        let NonRetCustTotal = this.GetNonRetCustomerTotalBasedOnTaxType(finalTotalsData, CustLaborTaxTotal, NonRetCustParrtTaxTotal, LaborList, PartsList, IsIndependentTax, Adjust);
+        if (isRoundable) {
+            finalTotalsData.Round = (0, aggregation_1.subtraction)(Math.round(CustTotal), CustTotal);
+            finalTotalsData.Total = Math.round(CustTotal);
+        }
+        else {
+            finalTotalsData.Total = tr_utils_1.TrUtils.FixedTo(CustTotal);
+        }
+        finalTotalsData.RetTotal = tr_utils_1.TrUtils.FixedTo(RetCustTotal);
+        finalTotalsData.NonRetTotal = tr_utils_1.TrUtils.FixedTo(NonRetCustTotal);
+        if (DetailedInfo) {
+            finalTotalsData.FixedSubTotal = tr_utils_1.TrUtils.FixedTo(CustomerAfterDiscTotals);
+            finalTotalsData.FixedTotal = tr_utils_1.TrUtils.FixedTo(CustTotal);
+            finalTotalsData.Adj = tr_utils_1.TrUtils.FixedTo(Adjust);
+        }
+        return finalTotalsData;
+    }
+    static GetSubTotalFor(LaborList, PartsList) {
+        let LaborTotalAfterDisc = this.GetLaborTotalAfterDiscount(LaborList);
+        let PartsTotalAfterDisc = this.GetPartsTotalAfterDiscount(PartsList);
+        return (0, aggregation_1.addition)(LaborTotalAfterDisc, PartsTotalAfterDisc);
+    }
+    static GetLaborTotalAfterDiscount(LaborList) {
+        let LaborTotalAfterDisc = 0;
+        LaborList.forEach((Labor) => {
+            LaborTotalAfterDisc = (0, aggregation_1.addition)(LaborTotalAfterDisc, Labor.AfterLaborDisc);
+        });
+        return LaborTotalAfterDisc;
+    }
+    static GetPartsTotalAfterDiscount(PartsList) {
+        let PartsTotalAfterDisc = 0;
+        let RetPartsTotalAfterDisc = 0;
+        PartsList.forEach((Part) => {
+            if (Part.Ret === true) {
+                RetPartsTotalAfterDisc = (0, aggregation_1.addition)(RetPartsTotalAfterDisc, Part.AfterPartDisc);
+            }
+            else {
+                PartsTotalAfterDisc = (0, aggregation_1.addition)(PartsTotalAfterDisc, Part.AfterPartDisc);
+            }
+        });
+        return (0, aggregation_1.subtraction)(PartsTotalAfterDisc, RetPartsTotalAfterDisc);
+    }
+    static GetRetPartsTotalAfterDiscount(PartsList) {
+        let RetPartsTotalAfterDisc = 0;
+        PartsList.forEach((Part) => {
+            if (Part.Ret === true) {
+                RetPartsTotalAfterDisc = (0, aggregation_1.addition)(RetPartsTotalAfterDisc, Part.AfterPartDisc);
+            }
+        });
+        return RetPartsTotalAfterDisc;
+    }
+    static GetNonRetPartsTotalAfterDiscount(PartsList) {
+        let NonRetPartsTotalAfterDisc = 0;
+        PartsList.forEach((Part) => {
+            if (tr_utils_1.TrUtils.IsNull(Part.Ret) || Part.Ret === false) {
+                NonRetPartsTotalAfterDisc = (0, aggregation_1.addition)(NonRetPartsTotalAfterDisc, Part.AfterPartDisc);
+            }
+        });
+        return NonRetPartsTotalAfterDisc;
+    }
+    static GetDetailedTotalsData(finalTotalsData, IsIndependentTax, opCodesList, PartsList, TaxCodes) {
+        finalTotalsData.CustLaborDiscTotal = this.GetLaborDiscountedTotal(opCodesList, IsIndependentTax, finalTotalsData);
+        finalTotalsData.CustPartsDiscTotal = this.GetPartDiscountedTotal(PartsList, IsIndependentTax, finalTotalsData);
+        finalTotalsData.CustLaborTotalAfterDisc = this.GetLaborTotalAfterDiscount(opCodesList);
+        finalTotalsData.CustPartsTotalAfterDisc = this.GetPartsTotalAfterDiscount(PartsList);
+        finalTotalsData.CustLaborTotalBeforeDisc = (0, aggregation_1.addition)(finalTotalsData.CustLaborTotalAfterDisc, finalTotalsData.CustLaborDiscTotal);
+        if (IsIndependentTax) {
+            finalTotalsData.CustPartsTotalBeforeDisc = (0, aggregation_1.addition)(finalTotalsData.CustPartsTotalAfterDisc, finalTotalsData.CustPartsDiscTotal);
+        }
+        else {
+            finalTotalsData.CustPartsTotalBeforeDisc = finalTotalsData.CustPartsTotalAfterDisc;
+        }
+        let LaborTaxInfo = this.GetLaborGSTTaxTotal(opCodesList, IsIndependentTax);
+        finalTotalsData.CustLaborITax = tr_utils_1.TrUtils.SetValueToZeroIfNull(LaborTaxInfo[3]);
+        finalTotalsData.CustLaborSGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(LaborTaxInfo[1]);
+        finalTotalsData.CustLaborCGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(LaborTaxInfo[0]);
+        finalTotalsData.CustLaborIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(LaborTaxInfo[2]);
+        let PartTaxInfo = this.GetPartGSTTaxTotal(PartsList, IsIndependentTax);
+        finalTotalsData.CustPartITax = this.GetPartsTaxTotalFor(PartsList, IsIndependentTax);
+        finalTotalsData.CustPartCGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(PartTaxInfo[0]);
+        finalTotalsData.CustPartIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(PartTaxInfo[2]);
+        finalTotalsData.CustPartSGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(PartTaxInfo[1]);
+        finalTotalsData.CustLaborAfterTax = (0, aggregation_1.addition)(finalTotalsData.CustLaborITax, finalTotalsData.CustLaborTotalAfterDisc);
+        finalTotalsData.CustPartAfterTax = (0, aggregation_1.addition)(finalTotalsData.CustPartITax, finalTotalsData.CustPartsTotalAfterDisc);
+        finalTotalsData.CustTaxGroupData = this.GetTaxGroupingForPartsByHSN(PartsList, TaxCodes);
+        finalTotalsData.CustTaxGroupDataByPerc = this.GetTaxGroupingForPartsByPerc(PartsList, TaxCodes);
+        finalTotalsData.CustLaborTaxGroupDataByPerc = this.GetTaxGroupingForLaborByPerc(opCodesList, TaxCodes);
+        finalTotalsData.CustTotalRoundedBy = tr_utils_1.TrUtils.FixedTo(finalTotalsData.Round);
+        finalTotalsData.CustRoundedTotal = tr_utils_1.TrUtils.FixedTo(finalTotalsData.Total);
+        finalTotalsData.CustRetRoundedTotal = tr_utils_1.TrUtils.FixedTo(finalTotalsData.RetTotal);
+        finalTotalsData.CustNonRetRoundedTotal = tr_utils_1.TrUtils.FixedTo(finalTotalsData.NonRetTotal);
+        for (var key in finalTotalsData) {
+            if (key !== 'Total' && key !== 'SubTotal' &&
+                key !== 'LDisc' && key !== 'LPerc' && key !== 'PDisc' &&
+                key !== 'PPerc' && key !== 'Disc' && key !== 'Perc' && key !== 'Tax'
+                && typeof finalTotalsData[key] === 'number') {
+                finalTotalsData[key] = tr_utils_1.TrUtils.FixPriceValue(finalTotalsData[key]);
+            }
+        }
+        return finalTotalsData;
+    }
+    static GetTaxGroupingForLaborByPerc(opCodesList, TaxCodes) {
+        opCodesList = this.GetCombinedTaxPercentage(tr_utils_1.TrUtils.Stringify(opCodesList), TaxCodes);
+        // opCodesList = this.ResetPartsHSNIfInvalid(opCodesList);
+        let FinalMatchedParts = this.CompareLaborByPerc(opCodesList, TaxCodes);
+        return this.GetTaxGroupingInfoBySAC(FinalMatchedParts, TaxCodes);
+    }
+    static GetTaxGroupingForPartsByPerc(Parts, TaxCodes) {
+        Parts = this.GetCombinedTaxPercentage(tr_utils_1.TrUtils.Stringify(Parts), TaxCodes);
+        // Parts = this.ResetPartsHSNIfInvalid(Parts);
+        let FinalMatchedParts = this.ComparePartsByPerc(Parts, TaxCodes);
+        return this.GetTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes);
+    }
+    static GetTaxGroupingInfoBySAC(FinalMatchedLabors, TaxCodes) {
+        let SACTaxInfo = [];
+        FinalMatchedLabors === null || FinalMatchedLabors === void 0 ? void 0 : FinalMatchedLabors.forEach((MatchedLabor) => {
+            let TaxInfo = {};
+            let TaxOnAmount = 0;
+            let TaxAmount = 0;
+            let CGSTAmt = 0;
+            let SGSTAmt = 0;
+            let IGSTAmt = 0;
+            let SAC = MatchedLabor[0].SAC;
+            TaxInfo.CombinedTaxPercentage = MatchedLabor[0].CombinedTaxPercentage;
+            MatchedLabor === null || MatchedLabor === void 0 ? void 0 : MatchedLabor.forEach((argMatchedGSTLabor) => {
+                TaxOnAmount = (0, aggregation_1.addition)(TaxOnAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTLabor.AfterLaborDisc));
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTLabor.CGST));
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTLabor.IGST));
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTLabor.SGST));
+                CGSTAmt = (0, aggregation_1.addition)(CGSTAmt, tr_utils_1.TrUtils.FixedTo(argMatchedGSTLabor.CGST));
+                SGSTAmt = (0, aggregation_1.addition)(SGSTAmt, tr_utils_1.TrUtils.FixedTo(argMatchedGSTLabor.SGST));
+                IGSTAmt = (0, aggregation_1.addition)(IGSTAmt, tr_utils_1.TrUtils.FixedTo(argMatchedGSTLabor.IGST));
+            });
+            TaxInfo.SAC = SAC;
+            TaxInfo.CGSTAmt = CGSTAmt;
+            TaxInfo.SGSTAmt = SGSTAmt;
+            TaxInfo.IGSTAmt = IGSTAmt;
+            TaxInfo.TotalTaxableAmount = tr_utils_1.TrUtils.FixPriceValue(TaxOnAmount);
+            TaxInfo.TotalTaxAmount = tr_utils_1.TrUtils.FixPriceValue(TaxAmount);
+            TaxInfo.ItemsCount = MatchedLabor.length;
+            let GSTValues = this.GetGSTValueBasedOnTaxCode(MatchedLabor[0].TCode, TaxCodes);
+            TaxInfo.CGST = GSTValues[0];
+            TaxInfo.SGST = GSTValues[1];
+            TaxInfo.IGST = GSTValues[2];
+            if (TaxOnAmount !== 0) {
+                SACTaxInfo.push(TaxInfo);
+            }
+        });
+        return SACTaxInfo;
+    }
+    static CompareLaborByPerc(opCodesList, TaxCodes) {
+        let FinalMatchedLabors = [];
+        opCodesList === null || opCodesList === void 0 ? void 0 : opCodesList.forEach((Labor) => {
+            let MatchedLaborsBasedOnPerc = opCodesList.filter((argLabor) => {
+                let PartFound = false;
+                FinalMatchedLabors.forEach((FinalArgLabors) => {
+                    let PartIndex = FinalArgLabors.findIndex((FinalArgPart) => {
+                        return FinalArgPart._id === argLabor._id;
+                    });
+                    if (PartIndex !== -1) {
+                        PartFound = true;
+                    }
+                });
+                // let argGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(argLabor.TCode, TaxCodes);
+                // let argCGST = argGSTValues[0];
+                // let argSGST = argGSTValues[1];
+                // let argIGST = argGSTValues[2];
+                // let laborGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(Labor.TCode, TaxCodes);
+                // let laborCGST = laborGSTValues[0];
+                // let laborSGST = laborGSTValues[1];
+                // let laborIGST = laborGSTValues[2];
+                return (!PartFound) &&
+                    (argLabor.CGSTAmt === Labor.CGSTAmt) && (argLabor.IGSTAmt === Labor.IGSTAmt) &&
+                    (argLabor.SGSTAmt === Labor.SGSTAmt);
+            });
+            if (MatchedLaborsBasedOnPerc.length !== 0) {
+                FinalMatchedLabors.push(MatchedLaborsBasedOnPerc);
+            }
+        });
+        return FinalMatchedLabors;
+    }
+    static ComparePartsByPerc(Parts, TaxCodes) {
+        let FinalMatchedParts = [];
+        Parts === null || Parts === void 0 ? void 0 : 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: any[] = this.GetGSTValueBasedOnTaxCode(argPart.TCode, TaxCodes);
+                // let argCGST = argGSTValues[0];
+                // let argSGST = argGSTValues[1];
+                // let argIGST = argGSTValues[2];
+                // let partGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+                // let partCGST = partGSTValues[0];
+                // let partSGST = partGSTValues[1];
+                // let partIGST = partGSTValues[2];
+                return (!PartFound) &&
+                    (argPart.CGSTAmt === Part.CGSTAmt) && (argPart.IGSTAmt === Part.IGSTAmt) &&
+                    (argPart.SGSTAmt === Part.SGSTAmt);
+            });
+            if (MatchedPartsBasedOnHSN.length !== 0) {
+                FinalMatchedParts.push(MatchedPartsBasedOnHSN);
+            }
+        });
+        return FinalMatchedParts;
+    }
+    static GetLaborDiscountedTotal(LaborList, isTaxable, finalTotalsData) {
+        let LaborDiscountedTotal = 0;
+        let overallLaborDisc = 0;
+        if (!isTaxable) {
+            overallLaborDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(finalTotalsData.LDisc);
+        }
+        else {
+            LaborList.forEach((Labor) => {
+                LaborDiscountedTotal = (0, aggregation_1.addition)(LaborDiscountedTotal, Labor.DiscountedPrice);
+            });
+        }
+        return (0, aggregation_1.addition)(LaborDiscountedTotal, overallLaborDisc);
+    }
+    static GetPartDiscountedTotal(PartsList, isTaxable, finalTotalsData) {
+        let PartsDiscountedTotal = 0;
+        let RetPartsDiscountedTotal = 0;
+        let overallPartDisc = 0;
+        if (!isTaxable) {
+            overallPartDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(finalTotalsData.PDisc);
+        }
+        else {
+            PartsList.forEach((Part) => {
+                if (Part.Ret === true) {
+                    RetPartsDiscountedTotal = (0, aggregation_1.addition)(RetPartsDiscountedTotal, Part.DiscountedPrice);
+                }
+                else {
+                    PartsDiscountedTotal = (0, aggregation_1.addition)(PartsDiscountedTotal, Part.DiscountedPrice);
+                }
+            });
+        }
+        return (0, aggregation_1.addition)((0, aggregation_1.subtraction)(PartsDiscountedTotal, RetPartsDiscountedTotal), overallPartDisc);
+    }
+    static GetLaborTaxTotalFor(opCodesList, IsIndependentTax) {
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            opCodesList.forEach((Labor) => {
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.CGST, Labor.SGST, Labor.IGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetPartsTaxTotalFor(PartsList, IsIndependentTax) {
+        let TotalTaxAmt = 0;
+        let RetTotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            PartsList.forEach((Part) => {
+                if (Part.Ret === true) {
+                    RetTotalTaxAmt = (0, aggregation_1.addition)(RetTotalTaxAmt, Part.CGST, Part.SGST, Part.IGST);
+                }
+                else {
+                    TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CGST, Part.SGST, Part.IGST);
+                }
+            });
+        }
+        return (0, aggregation_1.subtraction)(TotalTaxAmt, RetTotalTaxAmt);
+    }
+    static GetRetPartsTaxTotalFor(PartsList, IsIndependentTax) {
+        let RetTotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            PartsList.forEach((Part) => {
+                if (Part.Ret === true) {
+                    RetTotalTaxAmt = (0, aggregation_1.addition)(RetTotalTaxAmt, Part.CGST, Part.SGST, Part.IGST);
+                }
+            });
+        }
+        return RetTotalTaxAmt;
+    }
+    static GetNonRetPartsTaxTotalFor(PartsList, IsIndependentTax) {
+        let NonRetTotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            PartsList.forEach((Part) => {
+                if (tr_utils_1.TrUtils.IsNull(Part.Ret) || Part.Ret === false) {
+                    NonRetTotalTaxAmt = (0, aggregation_1.addition)(NonRetTotalTaxAmt, Part.CGST, Part.SGST, Part.IGST);
+                }
+            });
+        }
+        return NonRetTotalTaxAmt;
+    }
+    static GetCustomerTotalBasedOnTaxType(finalTotalsData, LaborTaxAmount, PartsTaxAmount, LaborList, PartsList, IsIndependentTax, Adjust) {
+        let LaborTotalAfterDisc = this.GetLaborTotalAfterDiscount(LaborList);
+        let PartsTotalAfterDisc = this.GetPartsTotalAfterDiscount(PartsList);
+        if (IsIndependentTax) {
+            return (0, aggregation_1.addition)(LaborTotalAfterDisc, PartsTotalAfterDisc, LaborTaxAmount, PartsTaxAmount, Adjust);
+        }
+        else {
+            return (0, aggregation_1.addition)((0, aggregation_1.subtraction)((0, aggregation_1.addition)((0, aggregation_1.subtraction)(LaborTotalAfterDisc, finalTotalsData.LDisc), (0, aggregation_1.subtraction)(PartsTotalAfterDisc, finalTotalsData.PDisc)), finalTotalsData.Disc), Adjust);
+        }
+    }
+    static GetRetCustomerTotalBasedOnTaxType(finalTotalsData, LaborTaxAmount, PartsTaxAmount, LaborList, PartsList, IsIndependentTax, Adjust) {
+        let LaborTotalAfterDisc = this.GetLaborTotalAfterDiscount(LaborList);
+        let PartsTotalAfterDisc = this.GetRetPartsTotalAfterDiscount(PartsList);
+        if (IsIndependentTax) {
+            return (0, aggregation_1.addition)(LaborTotalAfterDisc, PartsTotalAfterDisc, LaborTaxAmount, PartsTaxAmount);
+        }
+        else {
+            return tr_utils_1.TrUtils.FixedTo((0, aggregation_1.addition)((0, aggregation_1.subtraction)(LaborTotalAfterDisc, finalTotalsData.LDisc), (0, aggregation_1.subtraction)(PartsTotalAfterDisc, finalTotalsData.PDisc)));
+        }
+    }
+    static GetNonRetCustomerTotalBasedOnTaxType(finalTotalsData, LaborTaxAmount, PartsTaxAmount, LaborList, PartsList, IsIndependentTax, Adjust) {
+        let LaborTotalAfterDisc = this.GetLaborTotalAfterDiscount(LaborList);
+        let PartsTotalAfterDisc = this.GetNonRetPartsTotalAfterDiscount(PartsList);
+        if (IsIndependentTax) {
+            return (0, aggregation_1.addition)(LaborTotalAfterDisc, PartsTotalAfterDisc, LaborTaxAmount, PartsTaxAmount);
+        }
+        else {
+            return tr_utils_1.TrUtils.FixedTo((0, aggregation_1.addition)((0, aggregation_1.subtraction)(LaborTotalAfterDisc, finalTotalsData.LDisc), (0, aggregation_1.subtraction)(PartsTotalAfterDisc, finalTotalsData.PDisc)));
+        }
+    }
+    static LaborTotalAfterDiscount(LaborTotalAfterDisc, LaborTaxAmount, MainLDisc, LDiscInPerc) {
+        let LaborTotal = (0, aggregation_1.addition)(LaborTotalAfterDisc, LaborTaxAmount);
+        if (!tr_utils_1.TrUtils.IsZero(MainLDisc)) {
+            if (!tr_utils_1.TrUtils.IsEmpty(LDiscInPerc)) {
+                LaborTotal = (0, aggregation_1.subtraction)(LaborTotal, (0, aggregation_1.division)((0, aggregation_1.multiply)(LaborTotal, Number(LDiscInPerc)), 100));
+            }
+            else {
+                LaborTotal = (0, aggregation_1.subtraction)(LaborTotal, MainLDisc);
+            }
+        }
+        return LaborTotal;
+    }
+    static ItemsTotalAfterDiscount(PartsTotalAfterDisc, PartsTaxAmount, MainPDisc, PDiscInPerc) {
+        let ItemsTotal = (0, aggregation_1.addition)(PartsTotalAfterDisc, PartsTaxAmount);
+        if (!tr_utils_1.TrUtils.IsZero(MainPDisc)) {
+            if (!tr_utils_1.TrUtils.IsEmpty(PDiscInPerc)) {
+                ItemsTotal = (0, aggregation_1.subtraction)(ItemsTotal, (0, aggregation_1.division)((0, aggregation_1.multiply)(ItemsTotal, Number(PDiscInPerc)), 100));
+            }
+            else {
+                ItemsTotal = (0, aggregation_1.subtraction)(ItemsTotal, MainPDisc);
+            }
+        }
+        return ItemsTotal;
+    }
+    static GetLaborGSTTaxTotal(opCodesList, IsIndependentTax) {
+        let TotalCGSTAmt = 0;
+        let TotalSGSTAmt = 0;
+        let TotalIGSTAmt = 0;
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            opCodesList.forEach((Labor) => {
+                TotalCGSTAmt = (0, aggregation_1.addition)(TotalCGSTAmt, Labor.CGST);
+                TotalSGSTAmt = (0, aggregation_1.addition)(TotalSGSTAmt, Labor.SGST);
+                TotalIGSTAmt = (0, aggregation_1.addition)(TotalIGSTAmt, Labor.IGST);
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.CGST, Labor.SGST, Labor.IGST);
+            });
+        }
+        return [TotalCGSTAmt, TotalSGSTAmt, TotalIGSTAmt, TotalTaxAmt];
+    }
+    static GetPartGSTTaxTotal(PartsList, IsIndependentTax) {
+        let TotalCGSTAmt = 0;
+        let RetTotalCGSTAmt = 0;
+        let RetTotalIGSTAmt = 0;
+        let TotalIGSTAmt = 0;
+        let TotalSGSTAmt = 0;
+        let RetTotalSGSTAmt = 0;
+        if (IsIndependentTax) {
+            PartsList.forEach((Part) => {
+                if (Part.Ret === true) {
+                    RetTotalCGSTAmt = (0, aggregation_1.addition)(RetTotalCGSTAmt, Part.CGST);
+                    RetTotalSGSTAmt = (0, aggregation_1.addition)(RetTotalSGSTAmt, Part.SGST);
+                    RetTotalIGSTAmt = (0, aggregation_1.addition)(RetTotalIGSTAmt, Part.IGST);
+                }
+                else {
+                    TotalCGSTAmt = (0, aggregation_1.addition)(TotalCGSTAmt, Part.CGST);
+                    TotalSGSTAmt = (0, aggregation_1.addition)(TotalSGSTAmt, Part.SGST);
+                    TotalIGSTAmt = (0, aggregation_1.addition)(TotalIGSTAmt, Part.IGST);
+                }
+            });
+        }
+        return [TotalCGSTAmt, TotalSGSTAmt, TotalIGSTAmt];
+    }
+    static GetTaxGroupingForPartsByHSN(Parts, TaxCodes) {
+        Parts = this.GetCombinedTaxPercentage(tr_utils_1.TrUtils.Stringify(Parts), TaxCodes);
+        // Parts = this.ResetPartsHSNIfInvalid(Parts);
+        let FinalMatchedParts = this.ComparePartsByHSN(Parts, TaxCodes);
+        return this.GetTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes);
+    }
+    static GetCombinedTaxPercentage(Parts, TaxCodes) {
+        Parts.forEach((Part) => {
+            if (tr_utils_1.TrUtils.IsNull(Part.HSN)) {
+                Part.HSN = '';
+            }
+            let GSTValues = this.GetGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+            // let CGST = GSTValues[0];
+            // let SGST = GSTValues[1];
+            // let IGST = GSTValues[2];
+            Part.CGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(GSTValues[0]);
+            Part.SGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(GSTValues[1]);
+            Part.IGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(GSTValues[2]);
+            Part.CombinedTaxPercentage = (0, aggregation_1.addition)(Part.CGSTAmt, Part.SGSTAmt, Part.IGSTAmt);
+        });
+        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: any[] = this.GetGSTValueBasedOnTaxCode(argPart.TCode, TaxCodes);
+                // let argCGST = argGSTValues[0];
+                // let argSGST = argGSTValues[1];
+                // let argIGST = argGSTValues[2];
+                // let partGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+                // let partCGST = partGSTValues[0];
+                // let partSGST = partGSTValues[1];
+                // let partIGST = partGSTValues[2];
+                return (argPart.HSN === Part.HSN) && (!PartFound) &&
+                    (argPart.CGSTAmt === Part.CGSTAmt) && (argPart.IGSTAmt === Part.IGSTAmt) &&
+                    (argPart.SGSTAmt === Part.SGSTAmt);
+            });
+            if (MatchedPartsBasedOnHSN.length !== 0) {
+                FinalMatchedParts.push(MatchedPartsBasedOnHSN);
+            }
+        });
+        return FinalMatchedParts;
+    }
+    static GetTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes) {
+        let HSNTaxInfo = [];
+        FinalMatchedParts.forEach((MatchedPart) => {
+            let TaxInfo = {};
+            let TaxOnAmount = 0;
+            let TaxAmount = 0;
+            let CGSTAmt = 0;
+            let SGSTAmt = 0;
+            let IGSTAmt = 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.AfterPartDisc));
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.CGST));
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.IGST));
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.SGST));
+                CGSTAmt = (0, aggregation_1.addition)(CGSTAmt, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.CGST));
+                SGSTAmt = (0, aggregation_1.addition)(SGSTAmt, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.SGST));
+                IGSTAmt = (0, aggregation_1.addition)(IGSTAmt, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.IGST));
+            });
+            TaxInfo.HSN = HSN;
+            TaxInfo.CGSTAmt = CGSTAmt;
+            TaxInfo.SGSTAmt = SGSTAmt;
+            TaxInfo.IGSTAmt = IGSTAmt;
+            TaxInfo.TotalTaxableAmount = tr_utils_1.TrUtils.FixPriceValue(TaxOnAmount);
+            TaxInfo.TotalTaxAmount = tr_utils_1.TrUtils.FixPriceValue(TaxAmount);
+            TaxInfo.ItemsCount = MatchedPart.length;
+            // let GSTValues: any[] = this.GetGSTValueBasedOnTaxCode(MatchedPart[0].TCode, TaxCodes);
+            // TaxInfo.CGST = GSTValues[0];
+            // TaxInfo.SGST = GSTValues[1];
+            // TaxInfo.IGST = GSTValues[2];
+            TaxInfo.CGST = MatchedPart[0].CGSTAmt;
+            TaxInfo.IGST = MatchedPart[0].IGSTAmt;
+            TaxInfo.SGST = MatchedPart[0].SGSTAmt;
+            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];
+        }
+    }
+}
+exports.InvoiceTotalsService = InvoiceTotalsService;