shareneus 1.0.5

package/dist/services/vendor-credit-note-print.service.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VendorCreditNotePrintService = void 0;
+const code_enums_1 = require("../enums/code-enums");
+const my_date_1 = require("../utils/my-date");
+const tr_utils_1 = require("../utils/tr-utils");
+const shared_print_service_1 = require("./shared-print.service");
+const vendor_credit_note_totals_service_1 = require("./vendor-credit-note-totals.service");
+class VendorCreditNotePrintService {
+    //Prepare Pdf Data For Purchase Order And Bill
+    static GetDataForVendorCreditNotesPrint(argCNData, EntityData, image, IncludeGST, ConsolidateGST, TaxCodes) {
+        let CNData = tr_utils_1.TrUtils.Stringify(argCNData);
+        let creditNotePDFData = {};
+        creditNotePDFData.Settings = tr_utils_1.TrUtils.Stringify(argCNData.Settings);
+        // let IsTaxable: boolean = (CNData.Tax === 3) ? true : false;
+        let IsTaxable = true;
+        // PurchaseOrderPDFData.ShowTaxColumn = (CNData.Tax === 3) ? true : false;
+        // PurchaseOrderPDFData.HasTaxIncluded = (CNData.Tax === 2) ? true : false;
+        // PurchaseOrderPDFData.HideDiscountColumn = (CNData.Tax === 2) ? true : false;
+        creditNotePDFData.ShowTaxColumn = true;
+        creditNotePDFData.ShowTaxColumn = (IncludeGST && !ConsolidateGST) ? true : false;
+        creditNotePDFData.HasTaxIncluded = false;
+        creditNotePDFData.ShowDiscountColumn = (creditNotePDFData.Settings.DiscLvl === 'ITM' || creditNotePDFData.Settings.DiscLvl === 'RECITM') ? true : false;
+        // PurchaseOrderPDFData.HasNoTax = (CNData.Tax === 1) ? true : false;
+        creditNotePDFData.HasNoTax = false;
+        let SType;
+        if (!tr_utils_1.TrUtils.IsNull(argCNData.Settings) && !tr_utils_1.TrUtils.IsNull(argCNData.Settings.PoS)) {
+            SType = argCNData.Settings.PoS.SType;
+        }
+        creditNotePDFData.ShowIGST = (tr_utils_1.TrUtils.IsNull(CNData.SType) || (CNData.SType === 'Intra')) ? false : true;
+        creditNotePDFData.Id = CNData.BNo;
+        creditNotePDFData.CrDate = my_date_1.MyDate.ConvertUTCDateToReadable(CNData.CrDate);
+        creditNotePDFData.DeDate = my_date_1.MyDate.ConvertUTCDateToReadable(CNData.DeDate);
+        creditNotePDFData.Items = tr_utils_1.TrUtils.Stringify(CNData.Items);
+        // creditNotePDFData.Items = this.GetPartsDescription(creditNotePDFData.Items);
+        let DetailedTotalsInfo;
+        DetailedTotalsInfo = vendor_credit_note_totals_service_1.VendorCreditNoteTotalsService.GetTotalsValue([], creditNotePDFData.Items, IsTaxable, true, creditNotePDFData.Disc, creditNotePDFData.Perc, TaxCodes, true, creditNotePDFData.Settings);
+        creditNotePDFData = this.ConcatTotalsInfo(creditNotePDFData, DetailedTotalsInfo);
+        creditNotePDFData.Entity = shared_print_service_1.PrintSharedService.GetFormattedEntityDataForPrint(EntityData, code_enums_1.PrintTypesEnum.PurOrder, CNData);
+        creditNotePDFData = shared_print_service_1.PrintSharedService.GetEntityHeaderStyles(creditNotePDFData, EntityData, image);
+        creditNotePDFData.HeaderName = 'Vendor Credit Note';
+        creditNotePDFData.Vendor = this.GetVendorDataForPrint(tr_utils_1.TrUtils.Stringify(CNData.BFrom));
+        creditNotePDFData = this.FixPriceValuesForPrint(creditNotePDFData, TaxCodes);
+        return creditNotePDFData;
+    }
+    static GetVendorDataForPrint(argVendorData) {
+        let VendorPDFData = {};
+        let VendorData = tr_utils_1.TrUtils.Stringify(argVendorData);
+        // VendorPDFData.VendorType = VendorData.Type;
+        // if (VendorData.Type === CustomerTypesEnum.Individual) {
+        VendorPDFData.Name = VendorData.Name;
+        VendorPDFData.Contact = [
+            { Type: 'M', No: VendorData.Ph }
+        ];
+        // } else {
+        //     VendorPDFData.Name = VendorData.CName;
+        //     VendorPDFData.Contact = [
+        //         { Type: 'M', No: VendorData.MPhone }
+        //     ]
+        // }
+        VendorPDFData.Address = [];
+        if (!tr_utils_1.TrUtils.IsNull(VendorData.Adrs)) {
+            VendorPDFData.Address.push(VendorData.Adrs.A1);
+            if (!tr_utils_1.TrUtils.IsEmpty(VendorData.Adrs.A2)) {
+                VendorPDFData.Address.push(VendorData.Adrs.A2);
+            }
+            VendorPDFData.Address.push(VendorData.Adrs.Ct);
+        }
+        return VendorPDFData;
+    }
+    static ConcatTotalsInfo(creditNotePDFData, DetailedTotalsInfo) {
+        creditNotePDFData = tr_utils_1.TrUtils.ConcatObjects(creditNotePDFData, DetailedTotalsInfo);
+        return creditNotePDFData;
+    }
+    static FixPriceValuesForPrint(PrintData, TaxCodes) {
+        PrintData.ShowDetailedPartTaxInfo = false;
+        PrintData.Items.forEach((Part) => {
+            Part.UnPr = tr_utils_1.TrUtils.FixPriceValue(Part.Pr);
+            Part.DiscountedPrice = tr_utils_1.TrUtils.FixPriceValue(Part.DiscountedPrice);
+            Part.AfterTax = tr_utils_1.TrUtils.FixPriceValue(Part.AfterTax);
+            Part.CGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Part.CGST);
+            Part.IGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Part.IGST);
+            Part.SGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Part.SGST);
+            if (!tr_utils_1.TrUtils.CheckInvalidSelect(Part.TCode)) {
+                PrintData.ShowDetailedPartTaxInfo = true;
+            }
+            Part.CGSTPerc = shared_print_service_1.PrintSharedService.GetCGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+            Part.SGSTPerc = shared_print_service_1.PrintSharedService.GetSGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+            Part.IGSTPerc = shared_print_service_1.PrintSharedService.GetIGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+        });
+        PrintData.PartsDiscTotal = tr_utils_1.TrUtils.FixPriceValue(PrintData.CustItemsDiscTotal);
+        PrintData.PartsTotalAfterDisc = tr_utils_1.TrUtils.FixPriceValue(PrintData.CustItemsTotalAfterDisc);
+        PrintData.PartsTotalBeforeDisc = tr_utils_1.TrUtils.FixPriceValue(PrintData.CustItemsTotalBeforeDisc);
+        PrintData.TaxTotal = tr_utils_1.TrUtils.FixPriceValue(PrintData.TaxTotal);
+        PrintData.PartCGST = tr_utils_1.TrUtils.FixPriceValue(PrintData.CustItemCGST);
+        PrintData.PartIGST = tr_utils_1.TrUtils.FixPriceValue(PrintData.CustItemIGST);
+        PrintData.PartSGST = tr_utils_1.TrUtils.FixPriceValue(PrintData.CustItemSGST);
+        PrintData.PartAfterTax = tr_utils_1.TrUtils.FixPriceValue(PrintData.CustItemAfterTax);
+        PrintData.TotalRoundedBy = tr_utils_1.TrUtils.FixPriceValue(PrintData.CustTotalRoundedBy);
+        PrintData.RoundedTotal = tr_utils_1.TrUtils.FixPriceValue(PrintData.CustRoundedTotal);
+        return PrintData;
+    }
+}
+exports.VendorCreditNotePrintService = VendorCreditNotePrintService;

package/dist/services/vendor-credit-note-totals.service.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VendorCreditNoteTotalsService = void 0;
+const aggregation_1 = require("../aggregation/aggregation");
+const tr_utils_1 = require("../utils/tr-utils");
+class VendorCreditNoteTotalsService {
+    static GetTotalsValue(opCodesList, ItemsList, IsIndependentTax, DetailedInfo, Disc, Perc, TaxCodes, WithItems, Settings) {
+        // LPerc = TrUtils.SetPercToStringIfNull(LPerc);
+        // PPerc = TrUtils.SetPercToStringIfNull(PPerc);
+        Perc = tr_utils_1.TrUtils.SetPercToStringIfNull(Perc);
+        // LDisc = TrUtils.SetValueToZeroIfNull(LDisc);
+        // PDisc = TrUtils.SetValueToZeroIfNull(PDisc);
+        Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Disc);
+        // opCodesList = this.CalculateLaborValues(opCodesList, IsIndependentTax);
+        ItemsList = this.CalculateLaborItemValues(ItemsList, IsIndependentTax);
+        let finalTotalsData = this.GetFinalCNDataForSave(opCodesList, ItemsList, IsIndependentTax, Disc, Perc, DetailedInfo, Settings);
+        if (DetailedInfo) {
+            finalTotalsData = this.GetDetailedTotalsData(finalTotalsData, IsIndependentTax, opCodesList, ItemsList, TaxCodes);
+        }
+        if (WithItems) {
+            // finalTotalsData.Ops = opCodesList;
+            finalTotalsData.Items = ItemsList;
+        }
+        return finalTotalsData;
+    }
+    static CalculateLaborItemValues(ItemsList, IsIndependentTax) {
+        ItemsList = this.ResetLaborItemValues(ItemsList, IsIndependentTax);
+        // ItemsList = this.GetLaborItemsDiscountPrice(ItemsList);
+        // ItemsList = this.GetLaborItemsAfterDiscount(ItemsList);
+        // ItemsList = this.GetItemsAfterTax(ItemsList, IsIndependentTax);
+        return ItemsList;
+    }
+    static ResetLaborItemValues(ItemsList, IsIndependentTax) {
+        ItemsList.forEach((Item) => {
+            Item = this.ResetLaborItemValueIfInvalid(Item);
+            Item.DiscountedPrice = (0, aggregation_1.addition)(Item.Disc, Item.RecDisc);
+            Item.AfterItemDisc = Item.NetAmt;
+            if (IsIndependentTax) {
+                Item.AfterItemTax = (0, aggregation_1.addition)(Item.AfterItemDisc, Item.CGST, Item.SGST, Item.IGST);
+            }
+            else {
+                Item.AfterItemTax = Item.AfterItemDisc;
+            }
+        });
+        return ItemsList;
+    }
+    static ResetLaborItemValueIfInvalid(Item) {
+        Item.UnPr = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.UnPr);
+        Item.Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.Disc);
+        Item.RecDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.RecDisc);
+        Item.CGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.CGST);
+        Item.SGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.SGST);
+        Item.IGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.IGST);
+        return Item;
+    }
+    static GetFinalCNDataForSave(LaborList, ItemsList, IsIndependentTax, Disc, Perc, DetailedInfo, Settings) {
+        let finalTotalsData = {};
+        finalTotalsData = this.SetMainDiscountValues(Disc, Perc, finalTotalsData, DetailedInfo);
+        finalTotalsData.Settings = Settings;
+        finalTotalsData = this.GetFinalCustomerTotalsData(finalTotalsData, [], ItemsList, IsIndependentTax, DetailedInfo);
+        return finalTotalsData;
+    }
+    static SetMainDiscountValues(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 GetFinalCustomerTotalsData(finalTotalsData, LaborList, ItemsList, IsIndependentTax, DetailedInfo) {
+        let CustomerAfterDiscTotals = this.GetSubTotalFor([], ItemsList);
+        let CustLaborTaxTotal = this.GetLaborTaxTotalFor([], IsIndependentTax);
+        let CustItemTaxTotal = this.GetItemsTaxTotalFor(ItemsList, IsIndependentTax);
+        finalTotalsData.SubTotal = tr_utils_1.TrUtils.FixedTo(CustomerAfterDiscTotals);
+        // let CustLaborDiscTotal = this.GetLaborDiscountedTotal(LaborList, IsIndependentTax, finalTotalsData);
+        let CustItemsDiscTotal = this.GetItemDiscountedTotal(ItemsList, IsIndependentTax, finalTotalsData);
+        // let CustLaborTotalAfterDisc = this.GetLaborTotalAfterDiscount(LaborList);
+        let CustItemsTotalAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);
+        finalTotalsData.STotal = tr_utils_1.TrUtils.FixedTo(CustItemsDiscTotal + CustItemsTotalAfterDisc);
+        let CustTotal = this.GetCustomerTotalBasedOnTaxType(finalTotalsData, CustLaborTaxTotal, CustItemTaxTotal, [], ItemsList, IsIndependentTax);
+        finalTotalsData.Round = tr_utils_1.TrUtils.FixedTo(Math.round(CustTotal) - CustTotal);
+        finalTotalsData.Total = Math.round(CustTotal);
+        if (DetailedInfo) {
+            finalTotalsData.FixedSubTotal = tr_utils_1.TrUtils.FixedTo(CustomerAfterDiscTotals);
+            finalTotalsData.FixedTotal = tr_utils_1.TrUtils.FixedTo(CustTotal);
+        }
+        return finalTotalsData;
+    }
+    static GetSubTotalFor(LaborList, ItemsList) {
+        // let LaborTotalAfterDisc: any = this.GetLaborTotalAfterDiscount(LaborList);
+        let ItemsTotalAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);
+        return ItemsTotalAfterDisc;
+    }
+    static GetItemsTotalAfterDiscount(ItemsList) {
+        let ItemsTotalAfterDisc = 0;
+        ItemsList.forEach((Item) => {
+            ItemsTotalAfterDisc += Item.AfterItemDisc;
+        });
+        return ItemsTotalAfterDisc;
+    }
+    static GetDetailedTotalsData(finalTotalsData, IsIndependentTax, opCodesList, ItemsList, TaxCodes) {
+        // finalTotalsData.CustLaborDiscTotal = this.GetLaborDiscountedTotal(opCodesList, IsIndependentTax, finalTotalsData);
+        finalTotalsData.CustItemsDiscTotal = this.GetItemDiscountedTotal(ItemsList, IsIndependentTax, finalTotalsData);
+        // finalTotalsData.CustLaborTotalAfterDisc = this.GetLaborTotalAfterDiscount(opCodesList);
+        finalTotalsData.CustItemsTotalAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);
+        // finalTotalsData.CustLaborTotalBeforeDisc = TrUtils.FixedTo(finalTotalsData.CustLaborTotalAfterDisc
+        //     + finalTotalsData.CustLaborDiscTotal);
+        finalTotalsData.CustItemsTotalBeforeDisc = tr_utils_1.TrUtils.FixedTo(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 = this.GetItemGSTTaxTotal(ItemsList, IsIndependentTax);
+        finalTotalsData.CustItemITax = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[3]);
+        finalTotalsData.CustItemCGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[0]);
+        finalTotalsData.CustItemIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[2]);
+        finalTotalsData.CustItemSGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[1]);
+        // finalTotalsData.CustItemITax = this.GetItemsTaxTotalFor(ItemsList, IsIndependentTax);
+        // finalTotalsData.CustItemCGST = this.GetItemCGSTTaxTotal(ItemsList, IsIndependentTax);
+        // finalTotalsData.CustItemIGST = this.GetItemIGSTTaxTotal(ItemsList, IsIndependentTax);
+        // finalTotalsData.CustItemSGST = this.GetItemSGSTTaxTotal(ItemsList, IsIndependentTax);
+        // finalTotalsData.CustLaborAfterTax = TrUtils.FixedTo(finalTotalsData.CustLaborITax + finalTotalsData.CustLaborTotalAfterDisc);
+        finalTotalsData.CustItemAfterTax = tr_utils_1.TrUtils.FixedTo(finalTotalsData.CustItemITax + finalTotalsData.CustItemsTotalAfterDisc);
+        finalTotalsData.CustTaxGroupData = this.GetTaxGroupingForItemsByHSN(ItemsList, TaxCodes);
+        finalTotalsData.CustTotalRoundedBy = tr_utils_1.TrUtils.FixedTo(finalTotalsData.Round);
+        finalTotalsData.CustRoundedTotal = tr_utils_1.TrUtils.FixedTo(finalTotalsData.Total);
+        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 GetItemDiscountedTotal(ItemsList, isTaxable, finalTotalsData) {
+        let ItemsDiscountedTotal = 0;
+        let overallItemDisc = 0;
+        if (!isTaxable) {
+            overallItemDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(finalTotalsData.PDisc);
+        }
+        ItemsList.forEach((Item) => {
+            ItemsDiscountedTotal += Item.DiscountedPrice;
+        });
+        return tr_utils_1.TrUtils.FixedTo(ItemsDiscountedTotal + overallItemDisc);
+    }
+    static GetLaborTaxTotalFor(opCodesList, IsIndependentTax) {
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            opCodesList.forEach((Labor) => {
+                TotalTaxAmt = TotalTaxAmt + Labor.CGST + Labor.SGST + Labor.IGST;
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetItemsTaxTotalFor(ItemsList, IsIndependentTax) {
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            ItemsList.forEach((Item) => {
+                TotalTaxAmt = TotalTaxAmt + Item.CGST + Item.SGST + Item.IGST;
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetCustomerTotalBasedOnTaxType(finalTotalsData, LaborTaxAmount, ItemsTaxAmount, LaborList, ItemsList, IsIndependentTax) {
+        // let LaborTotalAfterDisc: any = this.GetLaborTotalAfterDiscount(LaborList);
+        let ItemsTotalAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);
+        if (IsIndependentTax) {
+            return ItemsTotalAfterDisc + LaborTaxAmount + ItemsTaxAmount;
+        }
+        else {
+            return tr_utils_1.TrUtils.FixedTo(ItemsTotalAfterDisc - finalTotalsData.Disc);
+        }
+    }
+    static LaborTotalAfterDiscount(LaborTotalAfterDisc, LaborTaxAmount, MainLDisc, LDiscInPerc) {
+        let LaborTotal = LaborTotalAfterDisc + LaborTaxAmount;
+        if (!tr_utils_1.TrUtils.IsZero(MainLDisc)) {
+            if (!tr_utils_1.TrUtils.IsEmpty(LDiscInPerc)) {
+                LaborTotal = (LaborTotal - (LaborTotal * Number(LDiscInPerc)) / 100);
+            }
+            else {
+                LaborTotal = LaborTotal - MainLDisc;
+            }
+        }
+        return LaborTotal;
+    }
+    static ItemsTotalAfterDiscount(ItemsTotalAfterDisc, ItemsTaxAmount, MainPDisc, PDiscInPerc) {
+        let ItemsTotal = ItemsTotalAfterDisc + ItemsTaxAmount;
+        if (!tr_utils_1.TrUtils.IsZero(MainPDisc)) {
+            if (!tr_utils_1.TrUtils.IsEmpty(PDiscInPerc)) {
+                ItemsTotal = (ItemsTotal - (ItemsTotal * Number(PDiscInPerc)) / 100);
+            }
+            else {
+                ItemsTotal = ItemsTotal - MainPDisc;
+            }
+        }
+        return ItemsTotal;
+    }
+    static GetItemGSTTaxTotal(ItemsList, IsIndependentTax) {
+        let TotalCGSTAmt = 0;
+        let TotalSGSTAmt = 0;
+        let TotalIGSTAmt = 0;
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            ItemsList.forEach((Item) => {
+                TotalCGSTAmt = (0, aggregation_1.addition)(TotalCGSTAmt, Item.CGST);
+                TotalSGSTAmt = (0, aggregation_1.addition)(TotalSGSTAmt, Item.SGST);
+                TotalIGSTAmt = (0, aggregation_1.addition)(TotalIGSTAmt, Item.IGST);
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Item.CGST, Item.SGST, Item.IGST);
+            });
+        }
+        return [TotalCGSTAmt, TotalSGSTAmt, TotalIGSTAmt, TotalTaxAmt];
+    }
+    static GetTaxGroupingForItemsByHSN(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 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(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 = (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 GSTValues: any[] = this.GetGSTValueBasedOnTaxCode(MatchedItem[0].TCode, TaxCodes);
+            // TaxInfo.CGST = GSTValues[0];
+            // TaxInfo.SGST = GSTValues[1];
+            // TaxInfo.IGST = GSTValues[2];
+            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, 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.VendorCreditNoteTotalsService = VendorCreditNoteTotalsService;