shareneus 1.7.4 → 1.7.6

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

@@ -0,0 +1,343 @@
+import { Add, Divide, Multiply, Subtract } from "../../shared/math-operations";
+import { TrUtils } from "../../utils/tr-utils";
+
+export class POTotalsService {
+
+    static GetTotalsValue(ItemsList: any, IsIndependentTax: boolean, DetailedInfo: boolean,
+        Disc: any, Perc: any, TaxCodes: any, WithItems: boolean, EntitySettings: any) {
+
+        ItemsList = this.CalculateItemValues(ItemsList);
+
+        let finalTotalsData: any = this.GetFinalPODataForSave(ItemsList, IsIndependentTax,
+            Disc, Perc, DetailedInfo, EntitySettings.DecimalsNumber);
+
+        if (DetailedInfo) {
+            finalTotalsData = this.GetDetailedTotalsData(finalTotalsData, IsIndependentTax, ItemsList, TaxCodes, EntitySettings.DecimalsNumber);
+        }
+        if (WithItems) {
+            finalTotalsData.Items = ItemsList;
+        }
+        return finalTotalsData;
+    }
+
+    static CalculateItemValues(ItemsList: any) {
+        ItemsList = this.ResetItemValues(ItemsList);
+
+        // ItemsList = this.GetItemsDiscountPrice(ItemsList);
+
+        // ItemsList = this.GetItemsAfterDiscount(ItemsList);
+
+        return ItemsList;
+    }
+
+    static ResetItemValues(ItemsList: any) {
+        ItemsList.forEach((Item: any) => {
+            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: any) {
+        Item.UnPr = TrUtils.SetValueToZeroIfNull(Item.UnPr);
+        Item.Disc = TrUtils.SetValueToZeroIfNull(Item.Disc);
+        Item.CCGST = TrUtils.SetValueToZeroIfNull(Item.CCGST);
+        Item.CSGST = TrUtils.SetValueToZeroIfNull(Item.CSGST);
+        Item.CIGST = TrUtils.SetValueToZeroIfNull(Item.CIGST);
+        return Item;
+    }
+
+    static GetItemDiscountedPrice(Price: any, Qty: any, Disc: any, DiscInPerc: boolean) {
+        if (DiscInPerc) {
+            return ((Price * Qty) * Disc) / 100;
+        } else {
+            return Disc;
+        }
+    }
+
+    static GetItemTotalAfterDiscount(Price: any, Qty: any, Disc: any, DiscInPerc: boolean) {
+        return ((Price * Qty) - this.GetItemDiscountedPrice(Price, Qty, Disc, DiscInPerc))
+    }
+
+    static GetFinalPODataForSave(ItemsList: any, IsIndependentTax: boolean,
+        Disc: any, Perc: any, DetailedInfo: boolean, DecimalsNumber: number) {
+
+        let finalTotalsData: any = {};
+
+        finalTotalsData = this.ResetRecordDiscountsIfInvalid(Disc, Perc, finalTotalsData, DetailedInfo);
+
+        finalTotalsData = this.GetFinalTotalsData(finalTotalsData, ItemsList,
+            IsIndependentTax, Disc, Perc, DetailedInfo, DecimalsNumber);
+
+        return finalTotalsData;
+    }
+
+    static ResetRecordDiscountsIfInvalid(Disc: any, Perc: boolean, finalTotalsData: any, DetailedInfo: boolean) {
+
+        Perc = TrUtils.SetPercToTrueIfNull(Perc);
+        Disc = TrUtils.SetValueToZeroIfNull(Disc);
+
+        finalTotalsData.Disc = Disc;
+        finalTotalsData.Perc = Perc;
+
+        if (DetailedInfo) {
+            finalTotalsData.FixedDisc = Disc;
+        }
+
+        return finalTotalsData;
+    }
+
+    static GetFinalTotalsData(finalTotalsData: any, ItemsList: any, IsIndependentTax: boolean,
+        Disc: any, Perc: boolean, DetailedInfo: boolean, DecimalsNumber: number) {
+        let AfterDiscTotals: number = this.GetSubTotal(ItemsList);
+
+        let ItemTaxTotal = this.GetItemsTaxTotal(ItemsList, IsIndependentTax);
+
+        finalTotalsData.SubTotal = TrUtils.FixedTo(AfterDiscTotals, DecimalsNumber);
+
+        let Total: any = this.GetTotalBasedOnTaxType(ItemTaxTotal, ItemsList,
+            IsIndependentTax, Disc, Perc);
+
+        finalTotalsData.Total = TrUtils.FixedTo(Total, DecimalsNumber);
+
+        finalTotalsData.ITax = IsIndependentTax;
+
+        if (DetailedInfo) {
+            finalTotalsData.FixedSubTotal = TrUtils.FixedTo(AfterDiscTotals, DecimalsNumber);
+            finalTotalsData.FixedTotal = TrUtils.FixedTo(Total, DecimalsNumber);
+        }
+
+        return finalTotalsData;
+    }
+
+    static GetSubTotal(ItemsList: any) {
+        let ItemsTotalAfterDisc: any = this.GetItemsTotalAfterDiscount(ItemsList);
+        return ItemsTotalAfterDisc;
+    }
+
+    static GetDetailedTotalsData(finalTotalsData: any, IsIndependentTax: boolean, ItemsList: any,
+        TaxCodes: any, DecimalsNumber: number) {
+
+        finalTotalsData.ItemsDiscTotal = this.GetItemDiscountedTotal(ItemsList);
+
+        finalTotalsData.ItemsTotalAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);
+
+        finalTotalsData.ItemsTotalBeforeDisc = TrUtils.FixedTo(Add(finalTotalsData.ItemsTotalAfterDisc
+            , finalTotalsData.ItemsDiscTotal), DecimalsNumber);
+
+        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: any = this.GetItemGSTTaxTotal(ItemsList);
+
+        finalTotalsData.ItemCGST = TrUtils.SetValueToZeroIfNull(TaxAmt[0]);
+        finalTotalsData.ItemSGST = TrUtils.SetValueToZeroIfNull(TaxAmt[1]);
+        finalTotalsData.ItemIGST = TrUtils.SetValueToZeroIfNull(TaxAmt[2]);
+
+        finalTotalsData.ItemAfterTax = TrUtils.FixedTo(Add(finalTotalsData.ItemITax , finalTotalsData.ItemsTotalAfterDisc), DecimalsNumber);
+
+        finalTotalsData.OverAllRecordDiscount = (finalTotalsData.Perc) ? Divide(Multiply(finalTotalsData.SubTotal , finalTotalsData.Disc), 100) : finalTotalsData.Disc;
+
+        finalTotalsData.TaxGroupData = this.GetItemsTaxGrouping(ItemsList, TaxCodes, DecimalsNumber);
+
+        finalTotalsData.TotalRoundedBy = TrUtils.FixedTo(Subtract(Math.round(finalTotalsData.Total), finalTotalsData.Total), DecimalsNumber);
+
+        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] = TrUtils.FixPriceValue(finalTotalsData[key], DecimalsNumber);
+            }
+        }
+
+        return finalTotalsData;
+    }
+
+    static GetItemGSTTaxTotal(ItemsList: Array<any>) {
+        let CGSTAmt: number = 0;
+        let SGSTAmt: number = 0;
+        let IGSTAmt: number = 0;
+        ItemsList.forEach((Item: any) => {
+            CGSTAmt = Add(CGSTAmt, Item.CGST);
+            SGSTAmt = Add(SGSTAmt, Item.SGST);
+            IGSTAmt = Add(IGSTAmt, Item.IGST);
+        });
+        return [CGSTAmt, SGSTAmt, IGSTAmt];
+    }
+
+    static GetItemDiscountedTotal(ItemsList: any) {
+        let ItemsDiscountedTotal: any = 0;
+        ItemsList.forEach((Item: any) => {
+            ItemsDiscountedTotal += Item.DiscountedPrice;
+        });
+        return ItemsDiscountedTotal;
+    }
+
+    static GetItemsTotalAfterDiscount(ItemsList: any) {
+        let ItemsTotalAfterDisc: any = 0;
+        ItemsList.forEach((Item: any) => {
+            ItemsTotalAfterDisc += Item.AfterItemDisc;
+        });
+        return ItemsTotalAfterDisc;
+    }
+
+    static GetItemsTaxTotal(ItemsList: any, IsIndependentTax: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsIndependentTax) {
+            ItemsList.forEach((Item: any) => {
+                TotalTaxAmt = TotalTaxAmt + Item.CCGST + Item.CSGST + Item.CIGST;
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetTotalBasedOnTaxType(ItemsTaxAmount: number, ItemsList: any,
+        IsIndependentTax: boolean, Discount: number, DiscInPerc: boolean) {
+
+        let SubTotalWithTax: any = 0;
+
+        let ItemsAfterDisc: any = this.GetItemsTotalAfterDiscount(ItemsList);
+
+        if (IsIndependentTax) {
+            SubTotalWithTax = ItemsAfterDisc + ItemsTaxAmount;
+        } else {
+            SubTotalWithTax = ItemsAfterDisc;
+        }
+
+        let Total = 0;
+        if (!TrUtils.IsZero(SubTotalWithTax)) {
+            if (DiscInPerc === true) {
+                Total = (SubTotalWithTax - (SubTotalWithTax * Discount) / 100);
+            } else {
+                Total = SubTotalWithTax - Discount;
+            }
+        }
+
+        return Total;
+    }
+
+    static GetItemsTaxGrouping(ItemsList: any, TaxCodes: any, DecimalsNumber: number) {
+        return this.GetTaxGroupingItemsByHSN(ItemsList, TaxCodes, DecimalsNumber);
+    }
+
+    static GetTaxGroupingItemsByHSN(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 = TrUtils.SetValueToZeroIfNull(TaxInfo[0]);
+            Item.SGSTAmt = TrUtils.SetValueToZeroIfNull(TaxInfo[1]);
+            Item.IGSTAmt = TrUtils.SetValueToZeroIfNull(TaxInfo[2]);
+            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 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: any, TaxCodes: any, DecimalsNumber: number) {
+        let HSNTaxInfo: any[] = [];
+        FinalMatchedItems.forEach((MatchedItem: any) => {
+            let TaxInfo: any = {};
+            let TaxOnAmount: any = 0;
+            let TaxAmount: any = 0;
+            let HSN: any = MatchedItem[0].HSN;
+            TaxInfo.CombinedTaxPercentage = MatchedItem[0].CombinedTaxPercentage;
+            MatchedItem.forEach((argMatchedGSTItem: any) => {
+                // TaxOnAmount += TrUtils.FixedTo(argMatchedGSTItem.AfterItemDisc);
+                // TaxAmount += TrUtils.FixedTo(argMatchedGSTItem.CCGST);
+                // TaxAmount += TrUtils.FixedTo(argMatchedGSTItem.CIGST);
+                // TaxAmount += TrUtils.FixedTo(argMatchedGSTItem.CSGST);
+                TaxOnAmount = Add(TaxOnAmount, argMatchedGSTItem.AfterItemDisc);
+                TaxAmount = Add(TaxAmount, argMatchedGSTItem.CGST);
+                TaxAmount = Add(TaxAmount, argMatchedGSTItem.IGST);
+                TaxAmount = Add(TaxAmount, argMatchedGSTItem.SGST);
+            });
+            TaxInfo.HSN = HSN;
+            TaxInfo.TotalTaxableAmount = TrUtils.FixPriceValue(TaxOnAmount, DecimalsNumber);
+            TaxInfo.TotalTaxAmount = TrUtils.FixPriceValue(TaxAmount, DecimalsNumber);
+            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: 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];
+        }
+    }
+
+}