shareneus 1.7.4 → 1.7.6

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

@@ -0,0 +1,376 @@
+
+import { TrUtils } from '../../utils/tr-utils';
+import { SOTypeEnum } from '../../enums/code-enums';
+import { MyDate } from '../../utils/my-date';
+import { InvoiceStatusEnum } from '../../enums/enums';
+import { PrintSharedService } from '../../shared/shared-print.service';
+import { SalesTotalsService } from './sales-totals.service';
+import { Add, Divide, Subtract } from '../../shared/math-operations';
+export class SalesPrintService {
+
+    static GetSalesPrintInfo(OriginalInvoiceData: any, OriginalEntityData: any, image: any,
+        IncludeGST: boolean, ConsolidateGST: boolean, TaxCodes: any, IsProforma: boolean, isOtherIndustry: boolean) {
+
+
+        let ForInsurance: boolean = !TrUtils.IsNull(OriginalInvoiceData.BillTo.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);
+        InvoicePrintData.DoS = TrUtils.Stringify(argInvoiceData.DoS);
+
+
+        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, OriginalInvoiceData.Type, OriginalInvoiceData);
+
+        InvoicePrintData = PrintSharedService.GetEntityHeaderStyles(InvoicePrintData, OriginalEntityData, image);
+
+        InvoicePrintData = this.GetInvoiceOtherDetailsForPrint(InvoicePrintData, argInvoiceData);
+        // console.log(InvoicePrintData);
+        let IsTaxable: boolean = (IncludeGST && TrUtils.isTaxable(argInvoiceData.Settings.Tax)) ? true : false;
+        // argInvoiceData.Items = argInvoiceData.Items.filter((item: any) => {
+        //     return TrUtils.IsNull(item.Type);
+        // });
+        let finalTotalsData: any = SalesTotalsService.GetTotalsValue(argInvoiceData.Items, IsTaxable,
+            true, argInvoiceData.PDisc, argInvoiceData.PPerc,
+            argInvoiceData.Disc, argInvoiceData.Perc, TaxCodes, true, argInvoiceData.Settings, InvoicePrintData.Entity.Round, InvoicePrintData.Entity);
+        if (ConsolidateGST) {
+            finalTotalsData.CustPartsTotalBeforeDisc = finalTotalsData.CustItemAfterTax;
+        }
+        InvoicePrintData = TrUtils.ConcatObjects(InvoicePrintData, finalTotalsData);
+        // InvoicePrintData.Ops = this.GetLaborPrintInfo(InvoicePrintData.Ops, ConsolidateGST, TaxCodes);
+        InvoicePrintData.Items = this.GetItemsPrintInfo(InvoicePrintData.Items, ConsolidateGST, TaxCodes, isOtherIndustry,OriginalEntityData.Entity.Settings?.Acc?.LTot, OriginalEntityData.Entity.DecimalsNumber);
+        // argInvoiceData = this.ReverseItemsForInvoicePrint(argInvoiceData);
+        InvoicePrintData.PrintInfo = this.PrepareFormatForInvoicePrint(InvoicePrintData, SOTypeEnum.SO, argInvoiceData.Sts);
+        InvoicePrintData = this.GetFormattedProductDataForPrint(argInvoiceData, InvoicePrintData);
+
+        InvoicePrintData = this.GetBillNameForInvoicePrint(argInvoiceData, InvoicePrintData);
+        InvoicePrintData = this.GetShipToForSOPrint(argInvoiceData, InvoicePrintData)
+        if (TrUtils.IsNull(argInvoiceData.Payments)) {
+            argInvoiceData.Payments = [];
+        }
+        let PaymentData = this.GetPaymentsTotal(argInvoiceData.Payments, InvoicePrintData.Total, argInvoiceData.Sts, OriginalEntityData.Entity.DecimalsNumber);
+        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 = (OriginalInvoiceData.Settings.DiscLvl === 'ITM' || OriginalInvoiceData.Settings.DiscLvl === 'RECITM') ? true : false;
+            // }
+        }
+        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 = 'SO';
+        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 {
+            InvoicePrintData.HeaderName = OriginalInvoiceData.Type;
+        }
+        return InvoicePrintData;
+    }
+
+    static GetInvoiceOtherDetailsForPrint(InvoicePrintData: any, OriginalInvoiceData: any) {
+        InvoicePrintData.Type = OriginalInvoiceData.Type;
+        InvoicePrintData._id = OriginalInvoiceData.Code;
+        InvoicePrintData.Sts = OriginalInvoiceData.Sts;
+        InvoicePrintData.CrDate = MyDate.ConvertUTCDateToReadable(OriginalInvoiceData.CrDate);
+        InvoicePrintData.RefNo = OriginalInvoiceData.RefNo;
+        return InvoicePrintData;
+    }
+
+    static GetItemsPrintInfo(Items: any, Consolidate: boolean, TaxCodes: any, isOtherIndustry: boolean, LineTotal:string, DecimalsNumber: number) {
+        let Amt: number = 0;
+        let TaxAmt: number = 0;
+        let TotalAmt: number = 0;
+        let DiscAmt: number = 0;
+        Items.forEach((Item: any) => {
+            if (TrUtils.IsNull(Item.Type) || Item.Type === 'Lab') {
+                const cgst = this.GetTaxAmountFromTaxes(Item, 'CGST');
+                const sgst = this.GetTaxAmountFromTaxes(Item, 'SGST');
+                const igst = this.GetTaxAmountFromTaxes(Item, 'IGST');
+                Amt = Amt + TrUtils.SetValueToZeroIfNull(Item.UnAmt);
+                DiscAmt = DiscAmt + TrUtils.SetValueToZeroIfNull(Item.Disc) + TrUtils.SetValueToZeroIfNull(Item.RecDisc);
+                TaxAmt = TaxAmt + cgst + sgst + igst;
+                let NetAmt: number = Subtract(Item.UnAmt, Item.Disc, Item.RecDisc);
+                TotalAmt = TotalAmt + TrUtils.SetValueToZeroIfNull(NetAmt) + cgst + sgst + igst;
+                if (Consolidate) {
+                    let AfterDiscForEach = Divide(Item.AfterItemDisc, Item.Qty);
+                    let CTaxAmtPerItem = Divide(cgst, Item.Qty);
+                    let STaxAmtPerItem = Divide(sgst, Item.Qty);
+                    let ITaxAmtPerItem = Divide(igst, Item.Qty);
+                    Item.UnPr = TrUtils.FixedTo(Add(AfterDiscForEach, CTaxAmtPerItem, STaxAmtPerItem, ITaxAmtPerItem), DecimalsNumber);
+                }else{
+                    Item.UnPr = TrUtils.FixPriceValue(Item.UnPr, DecimalsNumber);
+                }
+                if (isOtherIndustry && TrUtils.IsNull(Item.Type) && !TrUtils.IsNull(Item.Model) && !TrUtils.IsNull(Item.TR)) {
+                    Item.Desc = Item.Desc + '( ' + Item.Model + ',   ' + Item.TR + ' TR )';
+                }
+                Item.CGSTAmt = TrUtils.FixPriceValue(cgst, DecimalsNumber);
+                Item.SGSTAmt = TrUtils.FixPriceValue(sgst, DecimalsNumber);
+                Item.IGSTAmt = TrUtils.FixPriceValue(igst, DecimalsNumber);
+                Item.CGSTPerc = this.GetTaxRateFromTaxes(Item, 'CGST');
+                Item.SGSTPerc = this.GetTaxRateFromTaxes(Item, 'SGST');
+                Item.IGSTPerc = this.GetTaxRateFromTaxes(Item, 'IGST');
+                 Item.TCode = this.GetTCodeFromTaxes(Item);
+
+                if (LineTotal === 'AT') {
+                    Item.LineTotal = TrUtils.FixPriceValue(Item.AfterItemTax, 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;
+                }
+            } else {
+                if (Item.Type === 'Sub') {
+                    Item.LineTotal = TrUtils.FixedTo(Amt, DecimalsNumber);
+                    Amt = 0;
+                }
+                if (Item.Type === 'Tax') {
+                    Item.LineTotal = TrUtils.FixedTo(TaxAmt, DecimalsNumber);
+                    TaxAmt = 0;
+                }
+                if (Item.Type === 'Disc') {
+                    Item.LineTotal = TrUtils.FixedTo(DiscAmt, DecimalsNumber);
+                    DiscAmt = 0;
+                }
+                if (Item.Type === 'Tot') {
+                    Item.LineTotal = TrUtils.FixedTo(TotalAmt, DecimalsNumber);
+                    TotalAmt = 0;
+                }
+            }
+
+        });
+        return Items;
+    }
+
+ 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 ReverseItemsForInvoicePrint(argInvoiceData: any) {
+        // argInvoiceData.Ops = argInvoiceData.Ops.reverse();
+        argInvoiceData.Items = argInvoiceData.Items.reverse();
+        return argInvoiceData;
+    }
+
+    static PrepareFormatForInvoicePrint(InvoicePrintData: any, ROType: any, InvoiceStatus: any) {
+        let PrintInfo: any[] = [];
+
+        let ROLaborParts: any = {};
+
+        // ROLaborParts.Ops = InvoicePrintData.Ops;
+
+        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 GetShipToForSOPrint(OriginalInvoiceData: any, InvoicePrintData: any) {
+        let Customer: any = {};
+        Customer.Name = OriginalInvoiceData.ShipTo.Name;
+        Customer.DLNo = OriginalInvoiceData.ShipTo.DLNo;
+        Customer.Adrs = [];
+        Customer.Cons = [];
+        if (!TrUtils.IsNull(OriginalInvoiceData.ShipTo.Adrs)) {
+            Customer.Adrs.push(OriginalInvoiceData.ShipTo.Adrs.A1);
+            if (!TrUtils.IsEmpty(OriginalInvoiceData.ShipTo.Adrs.A2)) {
+                Customer.Adrs.push(OriginalInvoiceData.ShipTo.Adrs.A2);
+            }
+            if (!TrUtils.IsEmpty(OriginalInvoiceData.ShipTo.Adrs.Ct)) {
+                Customer.Adrs.push(OriginalInvoiceData.ShipTo.Adrs.Ct);
+            }
+        }
+        Customer.GSTIN = OriginalInvoiceData.ShipTo.GSTIN;
+
+        if (!TrUtils.IsEmpty(OriginalInvoiceData.ShipTo.Ph)) {
+            Customer.Cons = [
+                {
+                    Type: 'M',
+                    No: OriginalInvoiceData.ShipTo.Ph
+                }
+            ];
+        }
+        InvoicePrintData.ShippmentTo = Customer;
+
+        if (!TrUtils.IsNull(OriginalInvoiceData.ShipTo.InsId)) {
+            InvoicePrintData.Cust = this.GetCustomerDetails(OriginalInvoiceData);
+        }
+        return InvoicePrintData;
+    }
+
+    static GetBillNameForInvoicePrint(OriginalInvoiceData: any, InvoicePrintData: any) {
+        let Customer: any = {};
+        Customer.Name = OriginalInvoiceData.BillTo.Name;
+        Customer.DLNo = OriginalInvoiceData.BillTo.DLNo;
+        Customer.Adrs = [];
+        Customer.Cons = [];
+        if (!TrUtils.IsNull(OriginalInvoiceData.BillTo.Adrs)) {
+            Customer.Adrs.push(OriginalInvoiceData.BillTo.Adrs.A1);
+            if (!TrUtils.IsEmpty(OriginalInvoiceData.BillTo.Adrs.A2)) {
+                Customer.Adrs.push(OriginalInvoiceData.BillTo.Adrs.A2);
+            }
+            if (!TrUtils.IsEmpty(OriginalInvoiceData.BillTo.Adrs.Ct)) {
+                Customer.Adrs.push(OriginalInvoiceData.BillTo.Adrs.Ct);
+            }
+        }
+        Customer.GSTIN = OriginalInvoiceData.BillTo.GSTIN;
+
+        if (!TrUtils.IsEmpty(OriginalInvoiceData.BillTo.Ph)) {
+            Customer.Cons = [
+                {
+                    Type: 'M',
+                    No: OriginalInvoiceData.BillTo.Ph
+                }
+            ];
+        }
+        InvoicePrintData.Customer = Customer;
+
+        if (!TrUtils.IsNull(OriginalInvoiceData.BillTo.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 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 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(Subtract(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;
+    }
+
+}