shareneus 1.7.4 → 1.7.6

package/src/sales/sales/sales-totals.service.ts

@@ -0,0 +1,500 @@
+import { Add, Divide, Multiply, Subtract } from "../../shared/math-operations";
+import { TrUtils } from "../../utils/tr-utils";
+
+export class SalesTotalsService {
+
+    static GetTotalsValue(ItemsList: any, IsIndependentTax: boolean, DetailedInfo: boolean,
+        PDisc: any, PPerc: string, Disc: any, Perc: string,
+        TaxCodes: any, WithItems: boolean, Settings: any, isRoundable: boolean, EntitySettings: any) {
+
+        // LPerc = TrUtils.SetPercToStringIfNull(LPerc);
+        PPerc = TrUtils.SetPercToStringIfNull(PPerc);
+        Perc = TrUtils.SetPercToStringIfNull(Perc);
+        // LDisc = TrUtils.SetValueToZeroIfNull(LDisc);
+        PDisc = TrUtils.SetValueToZeroIfNull(PDisc);
+        Disc = TrUtils.SetValueToZeroIfNull(Disc);
+
+
+        // opCodesList = this.CalculateLaborValues(opCodesList, IsIndependentTax);
+
+        ItemsList = this.CalculateLaborItemValues(ItemsList, IsIndependentTax);
+
+        let finalTotalsData: any = this.GetFinalRODataForSave(ItemsList, IsIndependentTax,
+            PDisc, PPerc, Disc, Perc, DetailedInfo, Settings, isRoundable, EntitySettings);
+
+        if (DetailedInfo) {
+            finalTotalsData = this.GetDetailedTotalsData(finalTotalsData,
+                IsIndependentTax, ItemsList, TaxCodes, EntitySettings);
+        }
+
+        if (WithItems) {
+            finalTotalsData.Items = ItemsList;
+        }
+        return finalTotalsData;
+    }
+
+    static CalculateLaborItemValues(ItemsList: any, IsIndependentTax: boolean) {
+        ItemsList = this.ResetLaborItemValues(ItemsList, IsIndependentTax);
+
+        // ItemsList = this.GetLaborItemsDiscountPrice(ItemsList);
+
+        // ItemsList = this.GetLaborItemsAfterDiscount(ItemsList);
+
+        // ItemsList = this.GetItemsAfterTax(ItemsList, IsIndependentTax);
+
+        return ItemsList;
+    }
+
+    static ResetLaborItemValues(ItemsList: any, IsIndependentTax: boolean) {
+        ItemsList.forEach((Item: any) => {
+            Item = this.ResetLaborItemValueIfInvalid(Item);
+            Item.DiscountedPrice = Add(Item.Disc, Item.RecDisc);
+            let NetAmt: number = Subtract(Item.UnAmt, Item.Disc, Item.RecDisc);
+            Item.AfterItemDisc = TrUtils.SetValueToZeroIfNull(NetAmt);
+            if (IsIndependentTax) {
+                Item.AfterItemTax = Add(Item.AfterItemDisc, Item.CGST, Item.SGST, Item.IGST);
+            } else {
+                Item.AfterItemTax = Item.AfterItemDisc;
+            }
+        });
+        return ItemsList;
+    }
+
+    static ResetLaborItemValueIfInvalid(Item: any) {
+        Item.UnPr = TrUtils.SetValueToZeroIfNull(Item.UnPr);
+        Item.Disc = TrUtils.SetValueToZeroIfNull(Item.Disc);
+        Item.RecDisc = TrUtils.SetValueToZeroIfNull(Item.RecDisc);
+        Item.CGST = this.GetTaxAmountFromTaxes(Item, 'CGST');
+        Item.SGST = this.GetTaxAmountFromTaxes(Item, 'SGST');
+        Item.IGST = this.GetTaxAmountFromTaxes(Item, 'IGST');
+        Item.TCode = this.GetTCodeFromTaxes(Item);
+
+        return Item;
+    }
+
+    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 GetFinalRODataForSave(ItemsList: any, IsIndependentTax: boolean,
+        PDisc: string, PPerc: string, Disc: any, Perc: string,
+        DetailedInfo: boolean, Settings: any, isRoundable: boolean, DecimalsNumber: number) {
+
+        let finalTotalsData: any = {};
+
+        finalTotalsData = this.SetMainDiscountValues(PPerc, PDisc, Disc, Perc, finalTotalsData, DetailedInfo);
+
+        finalTotalsData.Settings = Settings;
+
+        finalTotalsData = this.GetFinalCustomerTotalsData(finalTotalsData, ItemsList,
+            IsIndependentTax, DetailedInfo, isRoundable, DecimalsNumber);
+
+        return finalTotalsData;
+    }
+
+    static SetMainDiscountValues(PPerc: string,
+        PDisc: any, Disc: any, Perc: string, finalTotalsData: any, DetailedInfo: boolean) {
+        finalTotalsData.PDisc = PDisc;
+        finalTotalsData.PPerc = PPerc;
+
+        finalTotalsData.Disc = Disc;
+        finalTotalsData.Perc = Perc;
+
+        if (DetailedInfo) {
+            finalTotalsData.FixedPDisc = PDisc;
+            finalTotalsData.FixedDisc = Disc;
+        }
+        return finalTotalsData;
+    }
+
+    static GetFinalCustomerTotalsData(finalTotalsData: any, ItemsList: any, IsIndependentTax: boolean,
+        DetailedInfo: boolean, isRoundable: boolean, DecimalsNumber: number) {
+        let CustomerAfterDiscTotals: number = this.GetSubTotalFor(ItemsList);
+
+        // let CustLaborTaxTotal = this.GetLaborTaxTotalFor(IsIndependentTax);
+
+        let CustItemTaxTotal = this.GetItemsTaxTotalFor(ItemsList, IsIndependentTax);
+        let CustItemsDiscTotal = this.GetItemDiscountedTotal(ItemsList);
+
+        finalTotalsData.SubTotal = Add(CustomerAfterDiscTotals, CustItemsDiscTotal);
+
+        let CustTotal: any = this.GetCustomerTotalBasedOnTaxType(CustItemTaxTotal, ItemsList, IsIndependentTax);
+
+        if (isRoundable) {
+            finalTotalsData.Round = Subtract(Math.round(CustTotal), CustTotal);
+            finalTotalsData.Total = Math.round(CustTotal);
+        } else {
+            finalTotalsData.Total = TrUtils.FixedTo(CustTotal, DecimalsNumber);
+        }
+
+
+
+        if (DetailedInfo) {
+            finalTotalsData.FixedSubTotal = TrUtils.FixedTo(CustomerAfterDiscTotals, DecimalsNumber);
+            finalTotalsData.FixedTotal = TrUtils.FixedTo(CustTotal, DecimalsNumber);
+        }
+
+
+        return finalTotalsData;
+    }
+
+    static GetSubTotalFor(ItemsList: any) {
+        // let LaborTotalAfterDisc: any = this.GetLaborTotalAfterDiscount(LaborList);
+        let ItemsTotalAfterDisc: any = this.GetItemsTotalAfterDiscount(ItemsList);
+        return ItemsTotalAfterDisc;
+    }
+
+    static GetItemsTotalAfterDiscount(ItemsList: any) {
+        let ItemsTotalAfterDisc: any = 0;
+        ItemsList.forEach((Item: any) => {
+            ItemsTotalAfterDisc = Add(ItemsTotalAfterDisc, Item.AfterItemDisc);
+        });
+        return ItemsTotalAfterDisc;
+    }
+
+    static GetDetailedTotalsData(finalTotalsData: any, IsIndependentTax: boolean, ItemsList: any, TaxCodes: any, DecimalsNumber: any) {
+        // finalTotalsData.CustLaborDiscTotal = this.GetLaborDiscountedTotal(opCodesList);
+
+        finalTotalsData.CustItemsDiscTotal = this.GetItemDiscountedTotal(ItemsList);
+
+        // finalTotalsData.CustLaborTotalAfterDisc = this.GetLaborTotalAfterDiscount(opCodesList);
+        finalTotalsData.CustItemsTotalAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);
+
+        finalTotalsData.CustLaborTotalBeforeDisc = Add(finalTotalsData.CustLaborTotalAfterDisc
+            , finalTotalsData.CustLaborDiscTotal);
+        finalTotalsData.CustItemsTotalBeforeDisc = Add(finalTotalsData.CustItemsTotalAfterDisc
+            , finalTotalsData.CustItemsDiscTotal);
+
+        // finalTotalsData.CustLaborITax = this.GetLaborTaxTotalFor(opCodesList, IsIndependentTax);
+        // finalTotalsData.CustLaborSGST = this.GetLaborSGSTTaxTotal(opCodesList, IsIndependentTax);
+        // finalTotalsData.CustLaborCGST = this.GetLaborCGSTTaxTotal(opCodesList, IsIndependentTax);
+        // finalTotalsData.CustLaborIGST = this.GetLaborIGSTTaxTotal(opCodesList, IsIndependentTax);
+
+        let TaxInfo: any = this.GetItemGSTTaxTotal(ItemsList, IsIndependentTax);
+        finalTotalsData.CustItemITax = TrUtils.SetValueToZeroIfNull(TaxInfo[3]);
+        finalTotalsData.CustItemCGST = TrUtils.SetValueToZeroIfNull(TaxInfo[0]);
+        finalTotalsData.CustItemIGST = TrUtils.SetValueToZeroIfNull(TaxInfo[2]);
+        finalTotalsData.CustItemSGST = TrUtils.SetValueToZeroIfNull(TaxInfo[1]);
+
+        // finalTotalsData.CustLaborAfterTax = TrUtils.FixedTo(finalTotalsData.CustLaborITax + finalTotalsData.CustLaborTotalAfterDisc);
+        finalTotalsData.CustItemAfterTax = Add(finalTotalsData.CustItemITax, finalTotalsData.CustItemsTotalAfterDisc);
+
+        finalTotalsData.CustTaxGroupData = this.GetTaxGroupingForItemsByHSN(ItemsList, TaxCodes, DecimalsNumber);
+        finalTotalsData.CustTaxGroupDataByPerc = this.GetTaxGroupingForPartsByPerc(ItemsList, TaxCodes, DecimalsNumber);
+
+        finalTotalsData.CustTotalRoundedBy = TrUtils.FixedTo(finalTotalsData.Round, DecimalsNumber);
+
+        finalTotalsData.CustRoundedTotal = TrUtils.FixedTo(finalTotalsData.Total, DecimalsNumber);
+
+        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] = TrUtils.FixPriceValue(finalTotalsData[key], DecimalsNumber);
+            }
+        }
+
+        return finalTotalsData;
+    }
+
+    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 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 GetLaborDiscountedTotal(LaborList: any) {
+        let LaborDiscountedTotal: any = 0;
+        LaborList.forEach((Labor: any) => {
+            LaborDiscountedTotal = Add(LaborDiscountedTotal, Labor.DiscountedPrice);
+        });
+        return LaborDiscountedTotal;
+    }
+
+    static GetItemDiscountedTotal(ItemsList: any) {
+        let ItemsDiscountedTotal: any = 0;
+        ItemsList.forEach((Item: any) => {
+            ItemsDiscountedTotal = Add(ItemsDiscountedTotal, Item.DiscountedPrice);
+        });
+        return ItemsDiscountedTotal;
+    }
+
+    static GetItemsTaxTotalFor(ItemsList: any, IsIndependentTax: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsIndependentTax) {
+            ItemsList.forEach((Item: any) => {
+                TotalTaxAmt = Add(TotalTaxAmt, Item.CGST, Item.SGST, Item.IGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetCustomerTotalBasedOnTaxType(ItemsTaxAmount: number, ItemsList: any, IsIndependentTax: boolean) {
+        // let LaborTotalAfterDisc: any = this.GetLaborTotalAfterDiscount(LaborList);
+        let ItemsTotalAfterDisc: any = this.GetItemsTotalAfterDiscount(ItemsList);
+        if (IsIndependentTax) {
+            return Add(ItemsTotalAfterDisc, ItemsTaxAmount);
+        } else {
+            return ItemsTotalAfterDisc;
+        }
+    }
+
+    static LaborTotalAfterDiscount(LaborTotalAfterDisc: number, LaborTaxAmount: number, MainLDisc: number, LDiscInPerc: string) {
+        let LaborTotal: number = Add(LaborTotalAfterDisc, LaborTaxAmount);
+        if (!TrUtils.IsZero(MainLDisc)) {
+            if (!TrUtils.IsEmpty(LDiscInPerc)) {
+                LaborTotal = Subtract(LaborTotal, Divide(Multiply(LaborTotal, Number(LDiscInPerc)), 100));
+            } else {
+                LaborTotal = Subtract(LaborTotal, MainLDisc);
+            }
+        }
+        return LaborTotal;
+    }
+
+    static ItemsTotalAfterDiscount(ItemsTotalAfterDisc: number, ItemsTaxAmount: number, MainPDisc: number, PDiscInPerc: string) {
+        let ItemsTotal: number = Add(ItemsTotalAfterDisc, ItemsTaxAmount);
+        if (!TrUtils.IsZero(MainPDisc)) {
+            if (!TrUtils.IsEmpty(PDiscInPerc)) {
+                ItemsTotal = Subtract(ItemsTotal, Divide(Multiply(ItemsTotal, Number(PDiscInPerc)), 100));
+            } else {
+                ItemsTotal = Subtract(ItemsTotal, MainPDisc);
+            }
+        }
+        return ItemsTotal;
+    }
+
+    static GetLaborCGSTTaxTotal(opCodesList: any, IsIndependentTax: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsIndependentTax) {
+            opCodesList.forEach((Labor: any) => {
+                TotalTaxAmt = Add(TotalTaxAmt, Labor.CGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetLaborIGSTTaxTotal(opCodesList: any, IsIndependentTax: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsIndependentTax) {
+            opCodesList.forEach((Labor: any) => {
+                TotalTaxAmt = Add(TotalTaxAmt, Labor.IGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetLaborSGSTTaxTotal(opCodesList: any, IsIndependentTax: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsIndependentTax) {
+            opCodesList.forEach((Labor: any) => {
+                TotalTaxAmt = Add(TotalTaxAmt, Labor.SGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetItemGSTTaxTotal(ItemsList: any, IsIndependentTax: boolean) {
+        let TotalCGSTAmt: number = 0;
+        let TotalSGSTAmt: number = 0;
+        let TotalIGSTAmt: number = 0;
+        let TotalTaxAmt: number = 0;
+        if (IsIndependentTax) {
+            ItemsList.forEach((Item: any) => {
+                TotalCGSTAmt = Add(TotalCGSTAmt, Item.CGST);
+                TotalSGSTAmt = Add(TotalSGSTAmt, Item.SGST);
+                TotalIGSTAmt = Add(TotalIGSTAmt, Item.IGST);
+                TotalTaxAmt = Add(TotalTaxAmt, Item.CGST, Item.SGST, Item.IGST);
+            });
+        }
+        return [TotalCGSTAmt, TotalSGSTAmt, TotalIGSTAmt, TotalTaxAmt];
+    }
+
+    static GetTaxGroupingForItemsByHSN(Items: any, TaxCodes: any, DecimalsNumber: number) {
+        Items = this.GetCombinedTaxPercentage(Items, TaxCodes);
+        // Items = this.ResetItemsHSNIfInvalid(Items);
+
+        let FinalMatchedItems: any[] = this.CompareItemsByHSN(Items, TaxCodes);
+
+        return this.GetTaxGroupingInfoByHSN(FinalMatchedItems, TaxCodes, DecimalsNumber);
+    }
+
+    static GetCombinedTaxPercentage(Items: any, TaxCodes: any) {
+        Items.forEach((Item: any) => {
+            if (TrUtils.IsNull(Item.HSN)) {
+                Item.HSN = '';
+            }
+            let TaxInfo = this.GetGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+            Item.CGSTAmt = this.GetTaxRateFromTaxes(Item, 'CGST');
+            Item.SGSTAmt = this.GetTaxRateFromTaxes(Item, 'SGST');
+            Item.IGSTAmt = this.GetTaxRateFromTaxes(Item, 'IGST');
+
+            Item.CombinedTaxPercentage = Add(Item.CGSTAmt, Item.SGSTAmt, Item.IGSTAmt);
+        });
+        return Items;
+    }
+
+    static CompareItemsByHSN(Items: any, TaxCodes: any) {
+        let FinalMatchedItems: any[] = [];
+        Items.forEach((Item: any) => {
+            let MatchedItemsBasedOnHSN = Items.filter((argItem: any) => {
+                let ItemFound: boolean = false;
+                FinalMatchedItems.forEach((FinalArgItems: any) => {
+                    let ItemIndex: any = FinalArgItems.findIndex((FinalArgItem: any) => {
+                        return FinalArgItem._id === argItem._id;
+                    });
+                    if (ItemIndex !== -1) {
+                        ItemFound = true;
+                    }
+                });
+
+                // let argGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(argItem.TCode, TaxCodes);
+                // let argCGST = argGSTValues[0];
+                // let argSGST = argGSTValues[1];
+                // let argIGST = argGSTValues[2];
+
+                // let ItemGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+                // let ItemCGST = ItemGSTValues[0];
+                // let ItemSGST = ItemGSTValues[1];
+                // let ItemIGST = ItemGSTValues[2];
+
+                return (argItem.HSN === Item.HSN) && (!ItemFound) &&
+                    (argItem.CGSTAmt === Item.CGSTAmt) && (argItem.IGSTAmt === Item.IGSTAmt) &&
+                    (argItem.SGSTAmt === Item.SGSTAmt);
+            });
+            if (MatchedItemsBasedOnHSN.length !== 0) {
+                FinalMatchedItems.push(MatchedItemsBasedOnHSN);
+            }
+        });
+        return FinalMatchedItems;
+    }
+
+    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.AfterPartDisc, 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;
+    }
+
+    static GetTaxAmountFromTaxes(item: any, taxCode: string, fallbackAmount: any = 0) {
+        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 TrUtils.SetValueToZeroIfNull(fallbackAmount);
+    }
+
+    static GetTaxRateFromTaxes(item: any, taxCode: string, fallbackRate: any = 0) {
+        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 TrUtils.SetValueToZeroIfNull(fallbackRate);
+    }
+
+    static GetGSTValueBasedOnTaxCode(TCode: any, TaxCodes: any) {
+        let CGST: number = 0;
+        let SGST: number = 0;
+        let IGST: number = 0;
+        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];
+        }
+    }
+
+}