shareneus 1.7.4 → 1.7.6

package/src/purchases/vendor-debit-note/vendor-debit-note-print.service.ts

@@ -0,0 +1,295 @@
+
+import { MyDate } from '../../utils/my-date';
+import { TrUtils } from '../../utils/tr-utils';
+import { InvoiceStatusEnum, PayTypeEnum } from '../../enums/enums';
+import { ROTypeEnum } from '../../enums/code-enums';
+import { DebitNoteTotalsService } from '../../accounting/debit-note/debit-note-totals.service';
+import { PrintSharedService } from '../../shared/shared-print.service';
+import { Add, Divide, Subtract } from '../../shared/math-operations';
+
+export class VendorDebitNotePrintService {
+
+    static GetDebitNotePrintInfo(OriginalInvoiceData: any, OriginalEntityData: any, image: any,
+        IncludeGST: boolean, ConsolidateGST: boolean, TaxCodes: any, IsProforma: boolean) {
+
+        let ForInsurance: boolean = !TrUtils.IsNull(OriginalInvoiceData.BFrom.InsId);
+
+        let InvoicePrintData: any = {};
+
+        let argInvoiceData = TrUtils.Stringify(OriginalInvoiceData);
+
+        if (!IncludeGST) {
+            argInvoiceData.Settings.Tax = 'NO';
+        }
+
+        InvoicePrintData.IsProforma = IsProforma;
+
+        InvoicePrintData.Settings = TrUtils.Stringify(argInvoiceData.Settings);
+        InvoicePrintData.SType = TrUtils.Stringify(argInvoiceData.SType);
+
+
+        let SType: any
+
+        if (!TrUtils.IsNull(OriginalInvoiceData.SType)) {
+            SType = OriginalInvoiceData.SType
+        }
+
+        InvoicePrintData = this.GetPrintConditionsBasedOnInput(InvoicePrintData, IncludeGST, ConsolidateGST, ForInsurance,
+            SType, argInvoiceData, IsProforma);
+
+        InvoicePrintData.Entity = PrintSharedService.GetFormattedEntityDataForPrint(OriginalEntityData, "Invoice", OriginalInvoiceData);
+
+        InvoicePrintData = PrintSharedService.GetEntityHeaderStyles(InvoicePrintData, OriginalEntityData, image);
+
+        InvoicePrintData = this.GetInvoiceOtherDetailsForPrint(InvoicePrintData, argInvoiceData);
+
+        let IsTaxable: boolean = (IncludeGST && TrUtils.isTaxable(argInvoiceData.Settings.Tax)) ? true : false;
+
+        let finalTotalsData: any = DebitNoteTotalsService.GetTotalsValue(argInvoiceData.Items, IsTaxable,
+            true, argInvoiceData.Disc, argInvoiceData.Perc, TaxCodes, true, argInvoiceData.Settings, InvoicePrintData.Entity);
+
+        if (ConsolidateGST) {
+            finalTotalsData.CustLaborTotalBeforeDisc = finalTotalsData.CustLaborAfterTax;
+            finalTotalsData.CustPartsTotalBeforeDisc = finalTotalsData.CustPartAfterTax;
+        }
+
+        InvoicePrintData = TrUtils.ConcatObjects(InvoicePrintData, finalTotalsData);
+
+        InvoicePrintData.Items = this.GetItemsPrintInfo(InvoicePrintData.Items, ConsolidateGST, TaxCodes, OriginalEntityData.Entity.Settings?.Acc?.LTot, OriginalEntityData.Entity.DecimalsNumber);
+
+        argInvoiceData = this.ReverseItemsForInvoicePrint(argInvoiceData);
+
+        InvoicePrintData.PrintInfo = this.PrepareFormatForInvoicePrint(InvoicePrintData, ROTypeEnum.Invoice, argInvoiceData.Sts);
+
+        InvoicePrintData = this.GetFormattedProductDataForPrint(argInvoiceData, InvoicePrintData);
+
+        InvoicePrintData = this.GetBillNameForInvoicePrint(argInvoiceData, InvoicePrintData);
+
+        // let PaymentData = this.GetPaymentsTotal(argInvoiceData.Payments, InvoicePrintData.Total, argInvoiceData.Sts);
+        // if (argInvoiceData.Settings.DiscLvl !== 'REC') {
+        //     InvoicePrintData.FixedDisc = null;
+        // }
+        // InvoicePrintData.Due = PaymentData.Due;
+        // InvoicePrintData.Paid = PaymentData.Paid;
+        // if (!TrUtils.IsNull(PaymentData.Sts)) {
+        //     InvoicePrintData.Sts = PaymentData.Sts;
+        // }
+        InvoicePrintData.Consolidate = ConsolidateGST;
+        if (!ForInsurance && !ConsolidateGST) {
+            // if (PrintSharedService.CheckItemIndexWithDisc(InvoicePrintData) !== -1) {
+            InvoicePrintData.ShowDiscountColumn = (InvoicePrintData.Settings.DiscLvl === 'ITM' || InvoicePrintData.Settings.DiscLvl === 'RECITM') ? true : false;
+
+            // }
+        }
+        // if (OriginalInvoiceData.Type === '1') {
+        //     InvoicePrintData.From = 'Sales';
+        // }
+
+        return InvoicePrintData;
+    }
+
+    static GetPrintConditionsBasedOnInput(InvoicePrintData: any, IncludeGST: boolean, ConsolidateGST: boolean,
+        ForInsurance: boolean, SType: any, OriginalInvoiceData: any, IsProforma: boolean) {
+
+        InvoicePrintData.ForInsurance = ForInsurance;
+        InvoicePrintData.For = ForInsurance ? PayTypeEnum.Insurance : PayTypeEnum.Customer;
+        InvoicePrintData.IncludeGST = IncludeGST;
+        InvoicePrintData.ConsolidateGST = ConsolidateGST;
+
+        InvoicePrintData.ShowAccParts = false;
+
+        InvoicePrintData.ShowIGST = (TrUtils.IsNull(SType) || (SType === 'Intra')) ? false : true;
+
+        InvoicePrintData.ShowTaxColumn = (IncludeGST && !ConsolidateGST) ? true : false;
+        // InvoicePrintData.ShowDiscountColumn = (!ForInsurance && !ConsolidateGST) ? true : false;
+
+        InvoicePrintData = this.GetInvoiceTypeHeading(InvoicePrintData, OriginalInvoiceData, IncludeGST, ConsolidateGST, IsProforma);
+
+        InvoicePrintData.PrDate = TrUtils.IsNull(OriginalInvoiceData.PrDate) ? '' : MyDate.ConvertUTCDateToReadable(OriginalInvoiceData.PrDate);
+
+        return InvoicePrintData;
+    }
+
+    static GetInvoiceTypeHeading(InvoicePrintData: any, OriginalInvoiceData: any, IncludeGST: boolean,
+        ConsolidateGST: boolean, IsProforma: boolean) {
+        if (IsProforma) {
+            InvoicePrintData.HeaderName = 'pro-forma Invoice';
+        } else {
+            // if (OriginalInvoiceData.Type === 'Sales') {
+            //     if (IncludeGST && !ConsolidateGST) {
+            //         InvoicePrintData.HeaderName = 'Parts Tax Invoice';
+            //     } else {
+            //         InvoicePrintData.HeaderName = 'Parts Invoice';
+            //     }
+            //     InvoicePrintData.PrintType = 'Parts Order';
+            // } else {
+            //     if (IncludeGST && !ConsolidateGST) {
+            //         InvoicePrintData.HeaderName = 'Tax Invoice';
+            //     } else {
+            //         InvoicePrintData.HeaderName = 'Invoice';
+            //     }
+            // }
+            InvoicePrintData.HeaderName = 'Debit Note';
+        }
+        return InvoicePrintData;
+    }
+
+    static GetInvoiceOtherDetailsForPrint(InvoicePrintData: any, OriginalInvoiceData: any) {
+        InvoicePrintData.Type = 'Debit Notes';
+        InvoicePrintData._id = OriginalInvoiceData.Code;
+        InvoicePrintData.Sts = OriginalInvoiceData.Sts;
+        InvoicePrintData.CrDate = MyDate.ConvertUTCDateToReadable(OriginalInvoiceData.CrDate);
+        return InvoicePrintData;
+    }
+
+    static GetItemsPrintInfo(Items: any, Consolidate: boolean, TaxCodes: any, LineTotal: string, DecimalsNumber: number) {
+        Items.forEach((Item: any) => {
+            if (Consolidate) {
+                let AfterDiscForEach = Divide(Item.AfterPartDisc, Item.Qty);
+                let CTaxAmtPerItem = Divide(Item.CGST, Item.Qty);
+                let STaxAmtPerItem = Divide(Item.SGST, Item.Qty);
+                let ITaxAmtPerItem = Divide(Item.IGST, Item.Qty);
+                Item.UnPr = TrUtils.FixedTo(Add(AfterDiscForEach, CTaxAmtPerItem, STaxAmtPerItem, ITaxAmtPerItem), DecimalsNumber);
+            }else{
+                Item.UnPr = TrUtils.FixPriceValue(Item.UnPr, DecimalsNumber);
+            }
+            Item.CGSTAmt = TrUtils.FixPriceValue(Item.CGST, DecimalsNumber);
+            Item.SGSTAmt = TrUtils.FixPriceValue(Item.SGST, DecimalsNumber);
+            Item.IGSTAmt = TrUtils.FixPriceValue(Item.IGST, DecimalsNumber);
+            Item.CGSTPerc = PrintSharedService.GetCGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+            Item.SGSTPerc = PrintSharedService.GetSGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+            Item.IGSTPerc = PrintSharedService.GetIGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+            if (LineTotal === 'AT') {
+                Item.LineTotal = TrUtils.FixPriceValue(Item.AfterPartTax, DecimalsNumber);
+            } else {
+                Item.LineTotal = TrUtils.FixPriceValue(Subtract(Item.UnAmt, Item.Disc), DecimalsNumber);
+            }
+            if (!TrUtils.IsZero(Item.Qty) && !TrUtils.CheckInvalidSelect(Item.UoM)) {
+                Item.QtyAndUoM = Item.Qty + ' ' + Item.UoM;
+            }
+        });
+        return Items;
+    }
+
+    static ReverseItemsForInvoicePrint(argInvoiceData: any) {
+        argInvoiceData.Items = argInvoiceData.Items.reverse();
+        return argInvoiceData;
+    }
+
+    static PrepareFormatForInvoicePrint(InvoicePrintData: any, ROType: any, InvoiceStatus: any) {
+        let PrintInfo: any[] = [];
+
+        let ROLaborParts: any = {};
+
+        ROLaborParts.Items = InvoicePrintData.Items;
+
+        ROLaborParts.Sts = InvoiceStatus;
+        ROLaborParts.Type = ROType;
+
+        PrintInfo.push(ROLaborParts);
+        return PrintInfo;
+    }
+
+    static GetFormattedProductDataForPrint(OriginalInvoiceData: any, InvoicePrintData: any) {
+        if (!TrUtils.IsNull(OriginalInvoiceData.Prod)) {
+            InvoicePrintData.Product = OriginalInvoiceData.Prod;
+            if (TrUtils.IsNull(InvoicePrintData.Product.VIN)) {
+                InvoicePrintData.Product.VIN = '';
+            }
+            if (TrUtils.IsNull(InvoicePrintData.Product.RegNo)) {
+                InvoicePrintData.Product.RegNo = '';
+            }
+            if (TrUtils.IsNull(InvoicePrintData.Product.EngNo)) {
+                InvoicePrintData.Product.EngNo = '';
+            }
+            InvoicePrintData.MIn = OriginalInvoiceData.Prod.MIn;
+            InvoicePrintData.MOut = OriginalInvoiceData.Prod.MOut;
+        }
+        return InvoicePrintData;
+    }
+
+    static GetBillNameForInvoicePrint(OriginalInvoiceData: any, InvoicePrintData: any) {
+        let Customer: any = {};
+        Customer.Name = OriginalInvoiceData.BFrom.Name;
+        Customer.Adrs = [];
+        Customer.Cons = [];
+        // if (!TrUtils.IsNull(OriginalInvoiceData.BFrom.Adrs)) {
+        //     Customer.Adrs.push(OriginalInvoiceData.BFrom.Adrs.A1);
+        //     if (!TrUtils.IsEmpty(OriginalInvoiceData.BFrom.Adrs.A2)) {
+        //         Customer.Adrs.push(OriginalInvoiceData.BFrom.Adrs.A2);
+        //     }
+        //     if (!TrUtils.IsEmpty(OriginalInvoiceData.BFrom.Adrs.Ct)) {
+        //         Customer.Adrs.push(OriginalInvoiceData.BFrom.Adrs.Ct);
+        //     }
+        // }
+        // Customer.GSTIN = OriginalInvoiceData.BFrom.GSTIN;
+
+        // if (!TrUtils.IsEmpty(OriginalInvoiceData.BFrom.Ph)) {
+        //     Customer.Cons = [
+        //         {
+        //             Type: 'M',
+        //             No: OriginalInvoiceData.BFrom.Ph
+        //         }
+        //     ];
+        // }
+        InvoicePrintData.Customer = Customer;
+
+        if (!TrUtils.IsNull(OriginalInvoiceData.BFrom.InsId)) {
+            InvoicePrintData.Cust = this.GetCustomerDetails(OriginalInvoiceData);
+        }
+        return InvoicePrintData;
+    }
+
+    static GetCustomerDetails(OriginalInvoiceData: any) {
+        let Customer: any = {};
+        Customer.Name = this.GetBillToName(OriginalInvoiceData.Cust.Title, OriginalInvoiceData.Cust.Name);
+        Customer.Cons = [];
+        if (!TrUtils.IsEmpty(OriginalInvoiceData.Cust.Ph)) {
+            Customer.Cons = [
+                {
+                    Type: 'M',
+                    No: OriginalInvoiceData.Cust.Ph
+                }
+            ];
+        }
+        Customer.GSTIN = OriginalInvoiceData.Cust.GSTIN;
+        Customer.Adrs = [];
+        if (!TrUtils.IsNull(OriginalInvoiceData.Cust.Adrs)) {
+            Customer.Adrs.push(OriginalInvoiceData.Cust.Adrs.A1);
+            if (!TrUtils.IsEmpty(OriginalInvoiceData.Cust.Adrs.A2)) {
+                Customer.Adrs.push(OriginalInvoiceData.Cust.Adrs.A2);
+            }
+            Customer.Adrs.push(OriginalInvoiceData.Cust.Adrs.Ct);
+        }
+        Customer.ConName = OriginalInvoiceData.Cust.ConName;
+        Customer.ConPh = OriginalInvoiceData.Cust.ConPhone;
+        return Customer;
+    }
+
+    static GetBillToName(Title: any, Name: string) {
+        return TrUtils.IsEmpty(Title) ? Name : Title + ' ' + Name;
+    }
+
+    // static GetPaymentsTotal(InvoicePayments: any, Total: number, InvoiceStatus: string, DecimalsNumber: number) {
+    //     var i = 0;
+    //     let Data: any = {};
+    //     let PaidTotal: any = 0;
+    //     for (i = 0; i < InvoicePayments.length; i++) {
+    //         PaidTotal += InvoicePayments[i].Paid;
+    //     }
+    //     if (InvoiceStatus === InvoiceStatusEnum.Closed) {
+    //         Data.Due = 0;
+    //     } else {
+    //         Data.Due = TrUtils.FixedTo((Total - PaidTotal), DecimalsNumber);
+    //     }
+    //     if (Data.Due < 0) {
+    //         Data.Due = 0;
+    //     }
+    //     if (Data.Due === 0) {
+    //         Data.Sts = InvoiceStatusEnum.Closed;
+    //     }
+    //     Data.Paid = TrUtils.FixedTo(PaidTotal, DecimalsNumber);
+    //     return Data;
+    // }
+
+}

package/src/purchases/vendor-debit-note/vendor-debit-note-totals.service.ts

@@ -0,0 +1,377 @@
+import { Add, Divide, Multiply, Subtract } from "../../shared/math-operations";
+import { TrUtils } from "../../utils/tr-utils";
+
+export class VendorDebitNoteTotalsService {
+
+    static GetTotalsValue(ItemsList: any, IsIndependentTax: boolean, DetailedInfo: boolean,
+        Disc: any, Perc: string,
+        TaxCodes: any, WithItems: boolean, Settings: any, 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, Disc, Perc, DetailedInfo, Settings, EntitySettings.DecimalsNumber);
+
+        if (DetailedInfo) {
+            finalTotalsData = this.GetDetailedTotalsData(finalTotalsData,
+                IsIndependentTax, ItemsList, TaxCodes, EntitySettings.DecimalsNumber);
+        }
+
+        if (WithItems) {
+            // finalTotalsData.Ops = opCodesList;
+            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);
+            if (TrUtils.IsZero(Item.Qty)) {
+                Item.Qty = 1;
+            }
+            Item.DiscountedPrice = Add(Item.Disc, Item.RecDisc);
+            Item.AfterItemDisc = Item.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 = TrUtils.SetValueToZeroIfNull(Item.CGST);
+        Item.SGST = TrUtils.SetValueToZeroIfNull(Item.SGST);
+        Item.IGST = TrUtils.SetValueToZeroIfNull(Item.IGST);
+        return Item;
+    }
+
+    static GetFinalRODataForSave(ItemsList: any, IsIndependentTax: boolean, Disc: any, Perc: string,
+        DetailedInfo: boolean, Settings: any, DecimalsNumber: number) {
+
+        let finalTotalsData: any = {};
+
+        finalTotalsData = this.SetMainDiscountValues(Disc, Perc, finalTotalsData, DetailedInfo);
+
+        finalTotalsData.Settings = Settings;
+
+        finalTotalsData = this.GetFinalCustomerTotalsData(finalTotalsData, ItemsList,
+            IsIndependentTax, DetailedInfo, DecimalsNumber);
+
+        return finalTotalsData;
+    }
+
+    static SetMainDiscountValues(Disc: string, Perc: string, finalTotalsData: any, DetailedInfo: boolean) {
+        // 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: any, ItemsList: any, IsIndependentTax: boolean,
+        DetailedInfo: boolean, DecimalsNumber: number) {
+        let CustomerAfterDiscTotals: number = this.GetSubTotalFor(ItemsList);
+
+        // let CustLaborTaxTotal = this.GetLaborTaxTotalFor(IsIndependentTax);
+
+        let CustItemTaxTotal = this.GetItemsTaxTotalFor(ItemsList, IsIndependentTax);
+
+        finalTotalsData.SubTotal = TrUtils.FixedTo(CustomerAfterDiscTotals, DecimalsNumber);
+        // 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 = Add(CustItemsDiscTotal, CustItemsTotalAfterDisc);
+
+        let CustTotal: any = this.GetCustomerTotalBasedOnTaxType(finalTotalsData, CustItemTaxTotal, ItemsList, IsIndependentTax);
+
+        finalTotalsData.Round = Subtract(Math.round(CustTotal), CustTotal);
+
+        finalTotalsData.Total = Math.round(CustTotal);
+
+        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: number) {
+        // 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 = 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.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 = Add(finalTotalsData.CustLaborITax , finalTotalsData.CustLaborTotalAfterDisc);
+        finalTotalsData.CustItemAfterTax = Add(finalTotalsData.CustItemITax, finalTotalsData.CustItemsTotalAfterDisc);
+
+        finalTotalsData.CustTaxGroupData = this.GetTaxGroupingForItemsByHSN(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 GetItemDiscountedTotal(ItemsList: any, isTaxable: boolean, finalTotalsData: any) {
+        let ItemsDiscountedTotal: any = 0;
+        let overallItemDisc: number = 0;
+        if (!isTaxable) {
+            overallItemDisc = TrUtils.SetValueToZeroIfNull(finalTotalsData.PDisc)
+        }
+        ItemsList.forEach((Item: any) => {
+            ItemsDiscountedTotal = Add(ItemsDiscountedTotal, Item.DiscountedPrice);
+        });
+        return Add(ItemsDiscountedTotal, overallItemDisc);
+    }
+
+    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(finalTotalsData: any, 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 Subtract(ItemsTotalAfterDisc, finalTotalsData.Disc);
+        }
+    }
+
+    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 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 = 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 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: 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 = 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 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: 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];
+        }
+    }
+
+}