shareneus 1.0.5

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

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POTotalsService = void 0;
+const aggregation_1 = require("../aggregation/aggregation");
+const tr_utils_1 = require("../utils/tr-utils");
+class POTotalsService {
+    static GetTotalsValue(ItemsList, IsIndependentTax, DetailedInfo, Disc, Perc, TaxCodes, WithItems) {
+        ItemsList = this.CalculateItemValues(ItemsList);
+        let finalTotalsData = this.GetFinalPODataForSave(ItemsList, IsIndependentTax, Disc, Perc, DetailedInfo);
+        if (DetailedInfo) {
+            finalTotalsData = this.GetDetailedTotalsData(finalTotalsData, IsIndependentTax, ItemsList, TaxCodes);
+        }
+        if (WithItems) {
+            finalTotalsData.Items = ItemsList;
+        }
+        return finalTotalsData;
+    }
+    static CalculateItemValues(ItemsList) {
+        ItemsList = this.ResetItemValues(ItemsList);
+        // ItemsList = this.GetItemsDiscountPrice(ItemsList);
+        // ItemsList = this.GetItemsAfterDiscount(ItemsList);
+        return ItemsList;
+    }
+    static ResetItemValues(ItemsList) {
+        ItemsList.forEach((Item) => {
+            Item = this.ResetItemValueIfInvalid(Item);
+            Item.DiscountedPrice = this.GetItemDiscountedPrice(Item.UnPr, Item.Qty, Item.Disc, Item.Perc);
+            Item.AfterItemDisc = this.GetItemTotalAfterDiscount(Item.UnPr, Item.Qty, Item.Disc, Item.Perc);
+        });
+        return ItemsList;
+    }
+    static ResetItemValueIfInvalid(Item) {
+        Item.UnPr = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.UnPr);
+        Item.Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.Disc);
+        Item.CCGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.CCGST);
+        Item.CSGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.CSGST);
+        Item.CIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.CIGST);
+        return Item;
+    }
+    static GetItemDiscountedPrice(Price, Qty, Disc, DiscInPerc) {
+        if (DiscInPerc) {
+            return ((Price * Qty) * Disc) / 100;
+        }
+        else {
+            return Disc;
+        }
+    }
+    static GetItemTotalAfterDiscount(Price, Qty, Disc, DiscInPerc) {
+        return ((Price * Qty) - this.GetItemDiscountedPrice(Price, Qty, Disc, DiscInPerc));
+    }
+    static GetFinalPODataForSave(ItemsList, IsIndependentTax, Disc, Perc, DetailedInfo) {
+        let finalTotalsData = {};
+        finalTotalsData = this.ResetRecordDiscountsIfInvalid(Disc, Perc, finalTotalsData, DetailedInfo);
+        finalTotalsData = this.GetFinalTotalsData(finalTotalsData, ItemsList, IsIndependentTax, Disc, Perc, DetailedInfo);
+        return finalTotalsData;
+    }
+    static ResetRecordDiscountsIfInvalid(Disc, Perc, finalTotalsData, DetailedInfo) {
+        Perc = tr_utils_1.TrUtils.SetPercToTrueIfNull(Perc);
+        Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Disc);
+        finalTotalsData.Disc = Disc;
+        finalTotalsData.Perc = Perc;
+        if (DetailedInfo) {
+            finalTotalsData.FixedDisc = Disc;
+        }
+        return finalTotalsData;
+    }
+    static GetFinalTotalsData(finalTotalsData, ItemsList, IsIndependentTax, Disc, Perc, DetailedInfo) {
+        let AfterDiscTotals = this.GetSubTotal(ItemsList);
+        let ItemTaxTotal = this.GetItemsTaxTotal(ItemsList, IsIndependentTax);
+        finalTotalsData.SubTotal = tr_utils_1.TrUtils.FixedTo(AfterDiscTotals);
+        let Total = this.GetTotalBasedOnTaxType(ItemTaxTotal, ItemsList, IsIndependentTax, Disc, Perc);
+        finalTotalsData.Total = tr_utils_1.TrUtils.FixedTo(Total);
+        finalTotalsData.ITax = IsIndependentTax;
+        if (DetailedInfo) {
+            finalTotalsData.FixedSubTotal = tr_utils_1.TrUtils.FixedTo(AfterDiscTotals);
+            finalTotalsData.FixedTotal = tr_utils_1.TrUtils.FixedTo(Total);
+        }
+        return finalTotalsData;
+    }
+    static GetSubTotal(ItemsList) {
+        let ItemsTotalAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);
+        return ItemsTotalAfterDisc;
+    }
+    static GetDetailedTotalsData(finalTotalsData, IsIndependentTax, ItemsList, TaxCodes) {
+        finalTotalsData.ItemsDiscTotal = this.GetItemDiscountedTotal(ItemsList);
+        finalTotalsData.ItemsTotalAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);
+        finalTotalsData.ItemsTotalBeforeDisc = tr_utils_1.TrUtils.FixedTo(finalTotalsData.ItemsTotalAfterDisc
+            + finalTotalsData.ItemsDiscTotal);
+        finalTotalsData.ItemITax = this.GetItemsTaxTotal(ItemsList, IsIndependentTax);
+        // finalTotalsData.ItemCGST = this.GetItemCGSTTaxTotal(ItemsList, IsIndependentTax);
+        // finalTotalsData.ItemIGST = this.GetItemIGSTTaxTotal(ItemsList, IsIndependentTax);
+        // finalTotalsData.ItemSGST = this.GetItemSGSTTaxTotal(ItemsList, IsIndependentTax);
+        let TaxAmt = this.GetItemGSTTaxTotal(ItemsList);
+        finalTotalsData.ItemCGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxAmt[0]);
+        finalTotalsData.ItemSGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxAmt[1]);
+        finalTotalsData.ItemIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxAmt[2]);
+        finalTotalsData.ItemAfterTax = tr_utils_1.TrUtils.FixedTo(finalTotalsData.ItemITax + finalTotalsData.ItemsTotalAfterDisc);
+        finalTotalsData.OverAllRecordDiscount = (finalTotalsData.Perc) ? ((finalTotalsData.SubTotal * finalTotalsData.Disc) / 100) : finalTotalsData.Disc;
+        finalTotalsData.TaxGroupData = this.GetItemsTaxGrouping(ItemsList, TaxCodes);
+        finalTotalsData.TotalRoundedBy = tr_utils_1.TrUtils.FixedTo(Math.round(finalTotalsData.Total) - finalTotalsData.Total);
+        finalTotalsData.RoundedTotal = Math.round(finalTotalsData.Total);
+        for (var key in finalTotalsData) {
+            if (key !== 'Total' && key !== 'SubTotal' &&
+                key !== 'Disc' && key !== 'Perc' && key !== 'ITax'
+                && typeof finalTotalsData[key] === 'number') {
+                finalTotalsData[key] = tr_utils_1.TrUtils.FixPriceValue(finalTotalsData[key]);
+            }
+        }
+        return finalTotalsData;
+    }
+    static GetItemGSTTaxTotal(ItemsList) {
+        let CGSTAmt = 0;
+        let SGSTAmt = 0;
+        let IGSTAmt = 0;
+        ItemsList.forEach((Item) => {
+            CGSTAmt = (0, aggregation_1.addition)(CGSTAmt, Item.CGST);
+            SGSTAmt = (0, aggregation_1.addition)(SGSTAmt, Item.SGST);
+            IGSTAmt = (0, aggregation_1.addition)(IGSTAmt, Item.IGST);
+        });
+        return [CGSTAmt, SGSTAmt, IGSTAmt];
+    }
+    static GetItemDiscountedTotal(ItemsList) {
+        let ItemsDiscountedTotal = 0;
+        ItemsList.forEach((Item) => {
+            ItemsDiscountedTotal += Item.DiscountedPrice;
+        });
+        return ItemsDiscountedTotal;
+    }
+    static GetItemsTotalAfterDiscount(ItemsList) {
+        let ItemsTotalAfterDisc = 0;
+        ItemsList.forEach((Item) => {
+            ItemsTotalAfterDisc += Item.AfterItemDisc;
+        });
+        return ItemsTotalAfterDisc;
+    }
+    static GetItemsTaxTotal(ItemsList, IsIndependentTax) {
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            ItemsList.forEach((Item) => {
+                TotalTaxAmt = TotalTaxAmt + Item.CCGST + Item.CSGST + Item.CIGST;
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetTotalBasedOnTaxType(ItemsTaxAmount, ItemsList, IsIndependentTax, Discount, DiscInPerc) {
+        let SubTotalWithTax = 0;
+        let ItemsAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);
+        if (IsIndependentTax) {
+            SubTotalWithTax = ItemsAfterDisc + ItemsTaxAmount;
+        }
+        else {
+            SubTotalWithTax = ItemsAfterDisc;
+        }
+        let Total = 0;
+        if (!tr_utils_1.TrUtils.IsZero(SubTotalWithTax)) {
+            if (DiscInPerc === true) {
+                Total = (SubTotalWithTax - (SubTotalWithTax * Discount) / 100);
+            }
+            else {
+                Total = SubTotalWithTax - Discount;
+            }
+        }
+        return Total;
+    }
+    static GetItemsTaxGrouping(ItemsList, TaxCodes) {
+        return this.GetTaxGroupingItemsByHSN(ItemsList, TaxCodes);
+    }
+    static GetTaxGroupingItemsByHSN(Items, TaxCodes) {
+        Items = this.GetCombinedTaxPercentage(Items, TaxCodes);
+        // Items = this.ResetItemsHSNIfInvalid(Items);
+        let FinalMatchedItems = this.CompareItemsByHSN(Items, TaxCodes);
+        return this.GetTaxGroupingInfoByHSN(FinalMatchedItems, TaxCodes);
+    }
+    static GetCombinedTaxPercentage(Items, TaxCodes) {
+        Items.forEach((Item) => {
+            if (tr_utils_1.TrUtils.IsNull(Item.HSN)) {
+                Item.HSN = '';
+            }
+            let TaxInfo = this.GetGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+            Item.CGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[0]);
+            Item.SGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[1]);
+            Item.IGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[2]);
+            Item.CombinedTaxPercentage = (0, aggregation_1.addition)(Item.CGSTAmt, Item.SGSTAmt, Item.IGSTAmt);
+        });
+        return Items;
+    }
+    static CompareItemsByHSN(Items, TaxCodes) {
+        let FinalMatchedItems = [];
+        Items.forEach((Item) => {
+            let MatchedItemsBasedOnHSN = Items.filter((argItem) => {
+                let ItemFound = false;
+                FinalMatchedItems.forEach((FinalArgItems) => {
+                    let ItemIndex = FinalArgItems.findIndex((FinalArgItem) => {
+                        return FinalArgItem._id === argItem._id;
+                    });
+                    if (ItemIndex !== -1) {
+                        ItemFound = true;
+                    }
+                });
+                // let argCGST = this.GetCGSTValueBasedOnTaxCode(argItem.TCode, TaxCodes);
+                // let argSGST = this.GetSGSTValueBasedOnTaxCode(argItem.TCode, TaxCodes);
+                // let argIGST = this.GetIGSTValueBasedOnTaxCode(argItem.TCode, TaxCodes);
+                // let ItemCGST = this.GetCGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+                // let ItemSGST = this.GetSGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+                // let ItemIGST = this.GetIGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+                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(FinalMatchedItems, TaxCodes) {
+        let HSNTaxInfo = [];
+        FinalMatchedItems.forEach((MatchedItem) => {
+            let TaxInfo = {};
+            let TaxOnAmount = 0;
+            let TaxAmount = 0;
+            let HSN = MatchedItem[0].HSN;
+            TaxInfo.CombinedTaxPercentage = MatchedItem[0].CombinedTaxPercentage;
+            MatchedItem.forEach((argMatchedGSTItem) => {
+                // TaxOnAmount += TrUtils.FixedTo(argMatchedGSTItem.AfterItemDisc);
+                // TaxAmount += TrUtils.FixedTo(argMatchedGSTItem.CCGST);
+                // TaxAmount += TrUtils.FixedTo(argMatchedGSTItem.CIGST);
+                // TaxAmount += TrUtils.FixedTo(argMatchedGSTItem.CSGST);
+                TaxOnAmount = (0, aggregation_1.addition)(TaxOnAmount, argMatchedGSTItem.AfterItemDisc);
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, argMatchedGSTItem.CGST);
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, argMatchedGSTItem.IGST);
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, argMatchedGSTItem.SGST);
+            });
+            TaxInfo.HSN = HSN;
+            TaxInfo.TotalTaxableAmount = tr_utils_1.TrUtils.FixPriceValue(TaxOnAmount);
+            TaxInfo.TotalTaxAmount = tr_utils_1.TrUtils.FixPriceValue(TaxAmount);
+            TaxInfo.ItemsCount = MatchedItem.length;
+            // let CGST = this.GetCGSTValueBasedOnTaxCode(MatchedItem[0].TCode, TaxCodes);
+            // let SGST = this.GetSGSTValueBasedOnTaxCode(MatchedItem[0].TCode, TaxCodes);
+            // let IGST = this.GetIGSTValueBasedOnTaxCode(MatchedItem[0].TCode, TaxCodes);
+            // TaxInfo.CGST = CGST;
+            // TaxInfo.IGST = IGST;
+            // TaxInfo.SGST = SGST;
+            TaxInfo.CGST = MatchedItem[0].CGSTAmt;
+            TaxInfo.IGST = MatchedItem[0].IGSTAmt;
+            TaxInfo.SGST = MatchedItem[0].SGSTAmt;
+            if (TaxOnAmount !== 0) {
+                HSNTaxInfo.push(TaxInfo);
+            }
+        });
+        return HSNTaxInfo;
+    }
+    static GetGSTValueBasedOnTaxCode(TCode, argTaxCodes) {
+        if (tr_utils_1.TrUtils.IsNull(TCode)) {
+            return [0, 0, 0];
+        }
+        let TaxCodes = tr_utils_1.TrUtils.Stringify(argTaxCodes);
+        let TCodeIndex = TaxCodes.findIndex((TaxCode) => {
+            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];
+        }
+    }
+}
+exports.POTotalsService = POTotalsService;