shareneus 1.7.4 → 1.7.6

package/src/purchases/purchase-order/purchase-order-totals.service.ts

@@ -0,0 +1,637 @@
+import { POPartStatusEnum } from "../../enums/code-enums";
+import { Add, Multiply, Subtract } from "../../shared/math-operations";
+import { TrUtils } from "../../utils/tr-utils";
+
+
+
+
+export class PurchaseOrderTotalsService {
+
+    static GetTaxAmountFromTaxes(item: any, taxCode: string) {
+        const taxes = Array.isArray(item?.Taxes) ? item.Taxes : [];
+        const matchedTaxes = taxes.filter((tax: any) => tax?.Code === taxCode);
+        if (matchedTaxes.length !== 0) {
+            return matchedTaxes.reduce((total: number, tax: any) => Add(total, tax?.Amt), 0);
+        }
+        return 0;
+    }
+
+    static GetTaxRateFromTaxes(item: any, taxCode: string) {
+        const taxes = Array.isArray(item?.Taxes) ? item.Taxes : [];
+        const matchedTaxes = taxes.filter((tax: any) => tax?.Code === taxCode);
+        if (matchedTaxes.length !== 0) {
+            return matchedTaxes.reduce((total: number, tax: any) => Add(total, tax?.Rate), 0);
+        }
+        return 0;
+    }
+
+    static GetTCodeFromTaxes(item: any) {
+        const taxes = Array.isArray(item?.Taxes) ? item.Taxes : [];
+        const matchedTax = taxes.find((tax: any) => !TrUtils.IsNull(tax?.TaxCodeId));
+        if (!TrUtils.IsNull(matchedTax?.TaxCodeId)) {
+            return matchedTax.TaxCodeId;
+        }
+        return item?.TCode;
+    }
+
+    static GetTotalsValue(opCodesList: any, argPartsList: any, IsTaxable: boolean, DetailedTotalsInfo: boolean,
+        TaxCodes: any, Tax: any, ReturnPartsAlso: boolean, HasNoTax: boolean, GetSubTotal: boolean, Discount: number, DiscInPerc: boolean, Adjust: number, EntitySettings: any) {
+        let PartsList: any[] = TrUtils.IsNull(argPartsList) ? [] : TrUtils.Stringify(argPartsList);
+
+        // PartsList = this.ResetPartValuesIfInvalid(PartsList);
+
+        // PartsList = this.GetPartsDiscountPrice(PartsList);
+
+        // PartsList = this.GetPartsAfterDiscount(PartsList);
+
+        if (TrUtils.IsNull(opCodesList)) {
+            opCodesList = [];
+        }
+
+        opCodesList = this.CalculateLaborValues(opCodesList, IsTaxable, EntitySettings.DecimalsNumber);
+
+        PartsList = this.GetPartsTaxAmount(PartsList, IsTaxable, TaxCodes, EntitySettings.DecimalsNumber);
+
+        // PartsList = this.GetPartsAfterTax(PartsList);
+
+        let finalTotalsData: any = this.GetTotalsInfo(PartsList, opCodesList, IsTaxable, TaxCodes, HasNoTax, GetSubTotal, Discount, DiscInPerc, Adjust, EntitySettings.DecimalsNumber);
+
+        if (ReturnPartsAlso) {
+            finalTotalsData.Ops = opCodesList;
+            finalTotalsData.Items = PartsList;
+        }
+
+        if (DetailedTotalsInfo === true) {
+            finalTotalsData = this.GetDetailedTotalsData(finalTotalsData, IsTaxable, PartsList, opCodesList, TaxCodes, Tax, HasNoTax, EntitySettings.DecimalsNumber);
+        }
+
+        return finalTotalsData;
+    }
+
+    static CalculateLaborValues(opCodesList: any, IsIndependentTax: boolean, DecimalsNumber: number) {
+        opCodesList = this.ResetLaborValues(opCodesList, IsIndependentTax, DecimalsNumber);
+
+        // opCodesList = this.GetOperationsDiscountPrice(opCodesList);
+
+        // opCodesList = this.GetOperationsAfterDiscount(opCodesList,IsIndependentTax);
+
+        // opCodesList = this.GetOperationsAfterTax(opCodesList, IsIndependentTax);
+
+        return opCodesList;
+    }
+
+    static ResetLaborValues(opCodesList: any, IsIndependentTax: boolean, DecimalsNumber: number) {
+        opCodesList.forEach((Operation: any) => {
+            Operation = this.ResetLaborValueIfInvalid(Operation);
+            Operation.DiscountedPrice = Add(Operation.Disc, Operation.RecDisc);
+            if (TrUtils.IsNull(Operation.Amt)) {
+                Operation.Amt = Operation.UnCo;
+            }
+            Operation.GSTAmt = Add(Operation.SGST, Operation.CGST, Operation.IGST);
+            if (IsIndependentTax) {
+                let NetAmt: number = Subtract(Operation.Amt, Operation.Disc, Operation.RecDisc);
+                Operation.AfterLaborDisc = NetAmt;
+                Operation.AfterLaborTax = Add(Operation.AfterLaborDisc, Operation.CGST, Operation.SGST, Operation.IGST);
+            } else {
+                Operation.AfterLaborDisc = Subtract(Operation.Amt, Operation.Disc);
+                Operation.AfterLaborTax = Operation.AfterLaborDisc;
+            }
+            let Price: any = 0;
+            Price = Multiply(Operation.UnCo, Operation.Qty)
+            if (IsIndependentTax) {
+                Operation.LineTotal = TrUtils.FixedTo(Add(Subtract(Price, Operation.Disc), Operation.GSTAmt), DecimalsNumber);
+
+            } else {
+                Operation.LineTotal = TrUtils.FixedTo(Subtract(Price, Operation.Disc), DecimalsNumber);
+            }
+        });
+        return opCodesList;
+    }
+
+    static ResetLaborValueIfInvalid(Operation: any) {
+        Operation.UnCo = TrUtils.SetValueToZeroIfNull(Operation.UnCo);
+        Operation.RecDisc = TrUtils.SetValueToZeroIfNull(Operation.RecDisc);
+        Operation.Disc = TrUtils.SetValueToZeroIfNull(Operation.Disc);
+        Operation.CGST = TrUtils.SetValueToZeroIfNull(this.GetTaxAmountFromTaxes(Operation, 'CGST') || Operation.CGST);
+        Operation.SGST = TrUtils.SetValueToZeroIfNull(this.GetTaxAmountFromTaxes(Operation, 'SGST') || Operation.SGST);
+        Operation.IGST = TrUtils.SetValueToZeroIfNull(this.GetTaxAmountFromTaxes(Operation, 'IGST') || Operation.IGST);
+        Operation.TCode = this.GetTCodeFromTaxes(Operation);
+        return Operation;
+    }
+    
+      static CheckPartStatusAndReturn(PartsList: any) {
+        PartsList = PartsList.filter((Part: any) => {
+            return Part.Sts !== POPartStatusEnum.Del && Part.Sts !== POPartStatusEnum.Deleted;
+        });
+        return PartsList;
+    }
+
+    static ResetPartValueIfInvalid(Part: any) {
+        // if (TrUtils.IsNull(Part.Ind)) {
+        if (TrUtils.IsNull(Part.UnCo)) {
+            Part.UnCo = TrUtils.SetValueToZeroIfNull(Part.UnPr);
+        }
+        Part.UnCo = TrUtils.SetValueToZeroIfNull(Part.UnCo);
+        Part.Disc = TrUtils.SetValueToZeroIfNull(Part.Disc);
+        Part.SGST = TrUtils.SetValueToZeroIfNull(this.GetTaxAmountFromTaxes(Part, 'SGST') || Part.SGST);
+        Part.IGST = TrUtils.SetValueToZeroIfNull(this.GetTaxAmountFromTaxes(Part, 'IGST') || Part.IGST);
+        Part.CGST = TrUtils.SetValueToZeroIfNull(this.GetTaxAmountFromTaxes(Part, 'CGST') || Part.CGST);
+        Part.TCode = this.GetTCodeFromTaxes(Part);
+        // }
+        return Part;
+    }
+
+    static GetPartDiscountedPrice(Disc: any, RecDisc: any) {
+        // if (DiscInPerc) {
+        //     return TrUtils.FixedTo(((Price * Qty) * Disc) / 100);
+        // } else {
+        return Add(Disc, TrUtils.SetValueToZeroIfNull(RecDisc));
+        // }
+    }
+
+    static GetPartsTaxAmount(Items: any, IsTaxable: boolean, TaxCodes: any, DecimalsNumber: number) {
+        Items.forEach((Part: any) => {
+            Part = this.ResetPartValueIfInvalid(Part);
+            // Part.CGSTAmt = this.GetCGSTTaxAmount(Part.AfterDiscountPrice, IsTaxable, Part.TCode, TaxCodes);
+            // Part.IGSTAmt = this.GetIGSTTaxAmount(Part.AfterDiscountPrice, IsTaxable, Part.TCode, TaxCodes);
+            // Part.SGSTAmt = this.GetSGSTTaxAmount(Part.AfterDiscountPrice, IsTaxable, Part.TCode, TaxCodes);
+            if (TrUtils.IsNull(Part.Ind)) {
+                Part.DiscountedPrice = this.GetPartDiscountedPrice(Part.Disc, Part.RecDisc);
+                // Part.AfterDiscountPrice = Part.NetAmt;
+                Part.AfterDiscountPrice = Subtract(Part.UnAmt, Part.Disc, Part.RecDisc);
+            }
+            Part.GSTAmt = Add(Part.SGST, Part.CGST, Part.IGST);
+            Part.Desc = Part.Name;
+            let Price: any = 0;
+            if (IsTaxable) {
+                // if (!TrUtils(Part.Perc)) {
+                Price = Multiply(Part.UnCo, Part.Qty)
+                Part.LineTotal = TrUtils.FixedTo(Add(Subtract(Price, Part.Disc), Part.GSTAmt), DecimalsNumber);
+                // } else {
+                //     Part.LineTotal = TrUtils.FixedTo((Part.UnPr - Part.Disc) + Part.GSTAmt);
+                // }
+            } else {
+                // let DiscPrice: any = 0;
+                // if (Part.Perc) {
+                Price = Multiply(Part.UnCo, Part.Qty)
+                Part.LineTotal = TrUtils.FixedTo(Subtract(Price, Part.Disc), DecimalsNumber);
+                // } else {
+                //     Part.LineTotal = TrUtils.FixedTo((Part.UnPr - Part.Disc));
+                // }
+            }
+            Part.AfterTax = Add(Part.AfterDiscountPrice, Part.GSTAmt);
+        });
+        return Items;
+    }
+
+    static GetGSTValueBasedOnTaxCode(TCode: any, argTaxCodes: any) {
+        if (TrUtils.IsNull(TCode)) {
+            return [0, 0, 0];
+        }
+        let TaxCodes: any = TrUtils.Stringify(argTaxCodes);
+        let TCodeIndex: any = TaxCodes.findIndex((TaxCode: any) => {
+            return TaxCode._id === Number(TCode);
+        });
+        if (TCodeIndex !== -1) {
+            // // if (TrUtils.IsNull(TaxCodes[TCodeIndex].CGST)) {
+            // //     return 0;
+            // // } else {
+            // return [TaxCodes[TCodeIndex].CGST, TaxCodes[TCodeIndex].SGST, TaxCodes[TCodeIndex].IGST];
+            // // }
+            if (TaxCodes[TCodeIndex].Type === 'Intra') {
+                return [TaxCodes[TCodeIndex].CGST, TaxCodes[TCodeIndex].SGST, 0];
+            } else {
+                return [0, 0, TaxCodes[TCodeIndex].IGST];
+            }
+        } else {
+            return [0, 0, 0];
+        }
+    }
+
+    static GetTotalsInfo(PartsList: any, LaborList: any, IsTaxable: boolean, TaxCodes: any, HasNoTax: boolean, GetSubTotal: boolean, Discount: number, DiscInPerc: boolean, Adjust: number, DecimalsNumber: number) {
+
+        let finalTotalsData: any = {};
+        let PartsInfo: any = this.GetPartsTotalTaxAndAfterDiscount(PartsList);
+        let PartsTotalAfterDisc: any = TrUtils.SetValueToZeroIfNull(PartsInfo[0]);
+        let PartsDiscTotal = TrUtils.SetValueToZeroIfNull(PartsInfo[1]);
+
+        let PartsTaxTotal = TrUtils.SetValueToZeroIfNull(PartsInfo[2]);
+
+        let ServicesInfo: any = this.GetServiceTotalTaxAndAfterDiscount(LaborList);
+        let ServicesTotalAfterDisc: any = TrUtils.SetValueToZeroIfNull(ServicesInfo[0]);
+        let ServicesDiscTotal = TrUtils.SetValueToZeroIfNull(ServicesInfo[1]);
+
+        let ServicesTaxTotal: any = TrUtils.SetValueToZeroIfNull(ServicesInfo[2]);
+        finalTotalsData.SubTotal = Add(PartsTotalAfterDisc, PartsDiscTotal, ServicesTotalAfterDisc, ServicesDiscTotal);
+        finalTotalsData.Adj = TrUtils.FixPriceValue(Adjust, DecimalsNumber);
+        // if (GetSubTotal) {
+        //     finalTotalsData.SubTotal = this.GetTotalBasedOnTaxType(PartsTotalAfterDisc, PartsTaxTotal,
+        //         IsTaxable);
+        //     let Total: number = finalTotalsData.SubTotal;
+        //     if (HasNoTax && !TrUtils.IsNull(Discount)) {
+        //         if (DiscInPerc) {
+        //             Total = TrUtils.FixedTo(((finalTotalsData.SubTotal) -
+        //                 ((finalTotalsData.SubTotal) * Discount) / 100));
+        //         } else {
+        //             Total = TrUtils.FixedTo((finalTotalsData.SubTotal) - Discount);
+        //         }
+        //     }
+        //     finalTotalsData.Total = Total;
+        // } else {
+        finalTotalsData.Total = this.GetTotalBasedOnTaxType(PartsTotalAfterDisc, PartsTaxTotal, ServicesTotalAfterDisc, ServicesTaxTotal,
+            IsTaxable, Adjust, DecimalsNumber);
+        // }
+        // finalTotalsData.Round = TrUtils.FixedTo(Math.round(finalTotalsData.Total) - finalTotalsData.Total);
+
+        // finalTotalsData.Total = Math.round(finalTotalsData.Total);
+        return finalTotalsData;
+    }
+
+    static GetServiceTotalTaxAndAfterDiscount(LaborList: any) {
+        let ServicesTotalAfterDisc: any = 0;
+        let ServicesDiscountedTotal: number = 0;
+        let TotalTaxAmt: number = 0;
+        LaborList.forEach((Part: any) => {
+            ServicesTotalAfterDisc = Add(ServicesTotalAfterDisc, Part.AfterLaborDisc);
+            ServicesDiscountedTotal = Add(ServicesDiscountedTotal, Part.DiscountedPrice);
+            TotalTaxAmt = Add(TotalTaxAmt, Part.GSTAmt);
+        });
+        return [ServicesTotalAfterDisc, ServicesDiscountedTotal, TotalTaxAmt];
+    }
+
+    static GetPartsTotalTaxAndAfterDiscount(PartsList: any) {
+        let PartsTotalAfterDisc: any = 0;
+        let PartsDiscountedTotal: number = 0;
+        let TotalTaxAmt: number = 0;
+        PartsList.forEach((Part: any) => {
+            PartsTotalAfterDisc = Add(PartsTotalAfterDisc, Part.AfterDiscountPrice);
+            PartsDiscountedTotal = Add(PartsDiscountedTotal, Part.DiscountedPrice);
+            TotalTaxAmt = Add(TotalTaxAmt, Part.GSTAmt);
+        });
+        return [PartsTotalAfterDisc, PartsDiscountedTotal, TotalTaxAmt];
+    }
+
+    static GetTotalBasedOnTaxType(PartsTotalAfterDisc: number, PartsTaxAmount: number,
+        ServicesTotalAfterDisc: number, ServicesTaxTotal: number, IsTaxable: boolean, Adjust: number, DecimalsNumber: number) {
+
+        let Total: number = 0;
+
+        if (IsTaxable) {
+            Total = Add(PartsTotalAfterDisc, PartsTaxAmount, ServicesTotalAfterDisc, ServicesTaxTotal);
+        } else {
+            Total = Add(PartsTotalAfterDisc, ServicesTotalAfterDisc);
+        }
+
+        let finalTotal: any = Add(Total, TrUtils.SetValueToZeroIfNull(Adjust));
+        return TrUtils.FixedTo(finalTotal, DecimalsNumber);
+    }
+
+    static GetDetailedTotalsData(finalTotalsData: any, IsTaxable: boolean, PartsList: any, LaborList: any, TaxCodes: any, Tax: any, HasNoTax: boolean, DecimalsNumber: number) {
+        let PartsInfo: any = this.GetPartsTotalTaxAndAfterDiscount(PartsList);
+        let ServicesInfo: any = this.GetServiceTotalTaxAndAfterDiscount(LaborList);
+
+        finalTotalsData.PartsDiscTotal = TrUtils.SetValueToZeroIfNull(PartsInfo[1]);
+
+        finalTotalsData.PartsTotalAfterDisc = TrUtils.SetValueToZeroIfNull(PartsInfo[0]);
+
+        finalTotalsData.PartsTotalBeforeDisc = Add(finalTotalsData.PartsTotalAfterDisc
+            , finalTotalsData.PartsDiscTotal);
+
+        // finalTotalsData.TaxTotal = this.GetPartsTaxTotal(PartsList);
+        finalTotalsData.TaxTotal = Add(TrUtils.SetValueToZeroIfNull(PartsInfo[2]), TrUtils.SetValueToZeroIfNull(ServicesInfo[2]));
+
+        finalTotalsData.ServiceTotalAfterDisc = TrUtils.SetValueToZeroIfNull(ServicesInfo[0]);
+        finalTotalsData.ServiceDiscTotal = TrUtils.SetValueToZeroIfNull(ServicesInfo[1]);
+
+        finalTotalsData.ServiceTaxTotal = TrUtils.SetValueToZeroIfNull(ServicesInfo[2]);
+
+        finalTotalsData.ServiceTotalBeforeDisc = Add(finalTotalsData.ServiceTotalAfterDisc
+            , finalTotalsData.ServiceDiscTotal);
+
+        let TaxAmt: any = this.GetPartGSTTaxTotal(PartsList);
+        // finalTotalsData.PartCGST = this.GetPartCGSTTaxTotal(PartsList);
+        // finalTotalsData.PartIGST = this.GetPartIGSTTaxTotal(PartsList);
+        // finalTotalsData.PartSGST = this.GetPartSGSTTaxTotal(PartsList);
+
+        finalTotalsData.PartCGST = TrUtils.SetValueToZeroIfNull(TaxAmt[0]);
+        finalTotalsData.PartSGST = TrUtils.SetValueToZeroIfNull(TaxAmt[1]);
+        finalTotalsData.PartIGST = TrUtils.SetValueToZeroIfNull(TaxAmt[2]);
+
+        let ServiceTaxAmt: any = this.GetServicesGSTTaxTotal(LaborList);
+        finalTotalsData.ServieCGST = TrUtils.SetValueToZeroIfNull(ServiceTaxAmt[0]);
+        finalTotalsData.ServieSGST = TrUtils.SetValueToZeroIfNull(ServiceTaxAmt[1]);
+        finalTotalsData.ServieIGST = TrUtils.SetValueToZeroIfNull(ServiceTaxAmt[2]);
+
+        finalTotalsData.PartAfterTax = Add(finalTotalsData.PartsTotalAfterDisc, finalTotalsData.TaxTotal);
+        finalTotalsData.ServiceAfterTax = Add(finalTotalsData.ServiceTotalAfterDisc, finalTotalsData.ServiceTaxTotal);
+
+        finalTotalsData.IsTaxable = IsTaxable;
+
+        finalTotalsData.Tax = Tax;
+
+        finalTotalsData.HasNoTax = HasNoTax;
+
+        finalTotalsData.TaxGroupData = this.GetPartsTaxGroupingFor(PartsList, TaxCodes, DecimalsNumber);
+        finalTotalsData.CustTaxGroupDataByPerc = this.GetTaxGroupingForPartsByPerc(PartsList, TaxCodes, DecimalsNumber);
+        finalTotalsData.CustLaborTaxGroupDataByPerc = this.GetTaxGroupingForLaborByPerc(LaborList, TaxCodes, DecimalsNumber);
+        finalTotalsData.TaxSummary = this.groupTaxData(finalTotalsData.CustTaxGroupData, finalTotalsData.CustLaborTaxGroupDataByPerc);
+
+
+        // finalTotalsData.TotalRoundedBy = TrUtils.FixedTo(Math.round(finalTotalsData.Total) - finalTotalsData.Total);
+
+        finalTotalsData.RoundedTotal = Math.round(finalTotalsData.Total);
+
+        // finalTotalsData.Round = TrUtils.FixedTo(Math.round(finalTotalsData.Total) - finalTotalsData.Total);
+
+        // finalTotalsData.Total = Math.round(finalTotalsData.Total);
+
+        return finalTotalsData;
+    }
+
+    static groupTaxData(
+        items: any[],
+        ops: any[]
+    ): any[] {
+        if (TrUtils.IsNull(items)) {
+            items = [];
+        }
+        if (TrUtils.IsNull(ops)) {
+            ops = [];
+        }
+        const combined = [...items, ...ops];
+
+        const groupedMap = new Map<number, { CombinedTaxPercentage: number; CGSTAmt: number; SGSTAmt: number; IGSTAmt?: number, TotalTaxAmount: number, TotalTaxableAmount: number }>();
+
+        combined.forEach(item => {
+            if (groupedMap.has(item.CombinedTaxPercentage)) {
+                const existing = groupedMap.get(item.CombinedTaxPercentage)!;
+                existing.CGSTAmt = Add(existing.CGSTAmt, item.CGSTAmt);
+                existing.SGSTAmt = Add(existing.SGSTAmt, item.SGSTAmt);
+
+                // Sum IGST if present
+                if (item.IGSTAmt !== undefined) {
+                    existing.IGSTAmt = Add(existing.IGSTAmt || 0, item.IGSTAmt);
+                }
+
+                existing.TotalTaxAmount = Add(existing.TotalTaxAmount || 0, item.TotalTaxAmount || 0);
+                existing.TotalTaxableAmount = Add(existing.TotalTaxableAmount || 0, item.TotalTaxableAmount || 0);
+            } else {
+                // Clone the object to avoid mutation
+                groupedMap.set(item.CombinedTaxPercentage, { ...item });
+            }
+        });
+
+        return Array.from(groupedMap.values());
+    }
+
+    static GetTaxGroupingForLaborByPerc(opCodesList: any, TaxCodes: any, DecimalsNumber: any) {
+        opCodesList = this.GetCombinedTaxPercentage(TrUtils.Stringify(opCodesList), TaxCodes);
+        // opCodesList = this.ResetPartsHSNIfInvalid(opCodesList);
+
+        let FinalMatchedParts: any[] = this.CompareLaborByPerc(opCodesList, TaxCodes);
+
+        return this.GetTaxGroupingInfoBySAC(FinalMatchedParts, TaxCodes, DecimalsNumber);
+    }
+
+    static GetTaxGroupingForPartsByPerc(Parts: any, TaxCodes: any, DecimalsNumber: any) {
+        Parts = this.GetCombinedTaxPercentage(TrUtils.Stringify(Parts), TaxCodes);
+        // Parts = this.ResetPartsHSNIfInvalid(Parts);
+
+        let FinalMatchedParts: any[] = this.ComparePartsByPerc(Parts, TaxCodes);
+        return this.GetTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes, DecimalsNumber);
+    }
+
+    static GetTaxGroupingInfoBySAC(FinalMatchedLabors: any, TaxCodes: any, DecimalsNumber: any) {
+        let SACTaxInfo: any[] = [];
+        FinalMatchedLabors?.forEach((MatchedLabor: any) => {
+            let TaxInfo: any = {};
+            let TaxOnAmount: any = 0;
+            let TaxAmount: any = 0;
+            let CGSTAmt: any = 0;
+            let SGSTAmt: any = 0;
+            let IGSTAmt: any = 0;
+            let SAC: any = MatchedLabor[0].SAC;
+            TaxInfo.CombinedTaxPercentage = MatchedLabor[0].CombinedTaxPercentage;
+            MatchedLabor?.forEach((argMatchedGSTLabor: any) => {
+                TaxOnAmount = Add(TaxOnAmount, TrUtils.FixedTo(argMatchedGSTLabor.AfterLaborDisc, DecimalsNumber));
+                TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTLabor.CGST, DecimalsNumber));
+                TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTLabor.IGST, DecimalsNumber));
+                TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTLabor.SGST, DecimalsNumber));
+                CGSTAmt = Add(CGSTAmt, TrUtils.FixedTo(argMatchedGSTLabor.CGST, DecimalsNumber));
+                SGSTAmt = Add(SGSTAmt, TrUtils.FixedTo(argMatchedGSTLabor.SGST, DecimalsNumber));
+                IGSTAmt = Add(IGSTAmt, TrUtils.FixedTo(argMatchedGSTLabor.IGST, DecimalsNumber));
+            });
+            TaxInfo.SAC = SAC;
+
+            TaxInfo.CGSTAmt = CGSTAmt;
+            TaxInfo.SGSTAmt = SGSTAmt;
+            TaxInfo.IGSTAmt = IGSTAmt;
+
+            TaxInfo.TotalTaxableAmount = TrUtils.FixPriceValue(TaxOnAmount, DecimalsNumber);
+            TaxInfo.TotalTaxAmount = TrUtils.FixPriceValue(TaxAmount, DecimalsNumber);
+            TaxInfo.ItemsCount = MatchedLabor.length;
+            let GSTValues: any[] = 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: any, TaxCodes: any) {
+        let FinalMatchedLabors: any[] = [];
+        opCodesList?.forEach((Labor: any) => {
+            let MatchedLaborsBasedOnPerc = opCodesList.filter((argLabor: any) => {
+                let PartFound: boolean = false;
+                FinalMatchedLabors.forEach((FinalArgLabors: any) => {
+                    let PartIndex: any = FinalArgLabors.findIndex((FinalArgPart: any) => {
+                        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: 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.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 GetPartGSTTaxTotal(PartsList: Array<any>) {
+        let CGSTAmt: number = 0;
+        let SGSTAmt: number = 0;
+        let IGSTAmt: number = 0;
+        PartsList.forEach((Part: any) => {
+            CGSTAmt = Add(CGSTAmt, Part.CGST);
+            SGSTAmt = Add(SGSTAmt, Part.SGST);
+            IGSTAmt = Add(IGSTAmt, Part.IGST);
+        });
+        return [CGSTAmt, SGSTAmt, IGSTAmt];
+    }
+
+    static GetServicesGSTTaxTotal(ServicesList: Array<any>) {
+        let CGSTAmt: number = 0;
+        let SGSTAmt: number = 0;
+        let IGSTAmt: number = 0;
+        ServicesList.forEach((labor: any) => {
+            CGSTAmt = Add(CGSTAmt, labor.CGST);
+            SGSTAmt = Add(SGSTAmt, labor.SGST);
+            IGSTAmt = Add(IGSTAmt, labor.IGST);
+        });
+        return [CGSTAmt, SGSTAmt, IGSTAmt];
+    }
+
+    static GetPartsTaxGroupingFor(PartsList: any, TaxCodes: any, DecimalsNumber: number) {
+        return this.GetTaxGroupingForPartsByHSN(TrUtils.Stringify(PartsList), TaxCodes, DecimalsNumber);
+    }
+
+    static GetTaxGroupingForPartsByHSN(Items: any, TaxCodes: any, DecimalsNumber: number) {
+        Items = this.GetCombinedTaxPercentage(Items, TaxCodes);
+        // Items = this.ResetPartsHSNIfInvalid(Items);
+        let FinalMatchedParts: any[] = this.ComparePartsByHSN(Items, TaxCodes);
+        return this.GetTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes, DecimalsNumber);
+    }
+
+    static GetCombinedTaxPercentage(Items: any, TaxCodes: any) {
+        Items.forEach((Part: any) => {
+            if (TrUtils.IsNull(Part.HSN)) {
+                Part.HSN = '';
+            }
+            Part.TCode = this.GetTCodeFromTaxes(Part);
+            Part.CGSTAmt = TrUtils.SetValueToZeroIfNull(this.GetTaxRateFromTaxes(Part, 'CGST'));
+            Part.SGSTAmt = TrUtils.SetValueToZeroIfNull(this.GetTaxRateFromTaxes(Part, 'SGST'));
+            Part.IGSTAmt = TrUtils.SetValueToZeroIfNull(this.GetTaxRateFromTaxes(Part, 'IGST'));
+            Part.CombinedTaxPercentage = Add(Part.CGSTAmt, Part.SGSTAmt, Part.IGSTAmt);
+        });
+        return Items;
+    }
+
+    static ComparePartsByHSN(Items: any, TaxCodes: any) {
+        let FinalMatchedParts: any[] = [];
+        Items.forEach((Part: any) => {
+            let MatchedPartsBasedOnHSN = Items.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 argCGST = this.GetCGSTValueBasedOnTaxCode(argPart.TCode, TaxCodes);
+                // let argSGST = this.GetSGSTValueBasedOnTaxCode(argPart.TCode, TaxCodes);
+                // let argIGST = this.GetIGSTValueBasedOnTaxCode(argPart.TCode, TaxCodes);
+                // let partCGST = this.GetCGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+                // let partSGST = this.GetSGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+                // let partIGST = this.GetIGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+                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: any, TaxCodes: any, DecimalsNumber: any) {
+        let HSNTaxInfo: any[] = [];
+        FinalMatchedParts.forEach((MatchedPart: any) => {
+            let TaxInfo: any = {};
+            let TaxOnAmount: any = 0;
+            let TaxAmount: any = 0;
+
+            let CGSTAmt: any = 0;
+            let SGSTAmt: any = 0;
+            let IGSTAmt: any = 0;
+
+            let HSN: any = MatchedPart[0].HSN;
+            TaxInfo.CombinedTaxPercentage = MatchedPart[0].CombinedTaxPercentage;
+            MatchedPart.forEach((argMatchedGSTPart: any) => {
+                TaxOnAmount = Add(TaxOnAmount, TrUtils.FixedTo(argMatchedGSTPart.AfterDiscountPrice, DecimalsNumber));
+                TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.CGST, DecimalsNumber));
+                TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.IGST, DecimalsNumber));
+                TaxAmount = Add(TaxAmount, TrUtils.FixedTo(argMatchedGSTPart.SGST, DecimalsNumber));
+                CGSTAmt = Add(CGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.CGST, DecimalsNumber));
+                SGSTAmt = Add(SGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.SGST, DecimalsNumber));
+                IGSTAmt = Add(IGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.IGST, DecimalsNumber));
+            });
+            TaxInfo.HSN = HSN;
+
+            TaxInfo.CGSTAmt = CGSTAmt;
+            TaxInfo.SGSTAmt = SGSTAmt;
+            TaxInfo.IGSTAmt = IGSTAmt;
+
+            TaxInfo.TotalTaxableAmount = TrUtils.FixPriceValue(TaxOnAmount, DecimalsNumber);
+            TaxInfo.TotalTaxAmount = TrUtils.FixPriceValue(TaxAmount, DecimalsNumber);
+            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;
+    }
+
+}