shareneus 1.7.4 → 1.7.6

package/src/accounting/invoice/inv-print.service.ts

@@ -0,0 +1,532 @@
+
+
+import { ROTypeEnum } from '../../enums/code-enums';
+import { InvoiceStatusEnum, PayTypeEnum } from '../../enums/enums';
+import { Add, Divide, Multiply, Subtract } from '../../shared/math-operations';
+import { PrintSharedService } from '../../shared/shared-print.service';
+import { MyDate } from '../../utils/my-date';
+import { TrUtils } from '../../utils/tr-utils';
+import { InvoiceTotalsService } from './invoice-total.service';
+
+export function GetInvoicePrintInfo(OriginalInvoiceData: any, OriginalEntityData: any, image: any,
+        IncludeGST: boolean, ConsolidateGST: boolean, TaxCodes: any, IsProforma: boolean, PartsPrint: boolean, LaborPrint: boolean) {
+
+        let ForInsurance: boolean = !TrUtils.IsNull(OriginalInvoiceData.BillTo) && !TrUtils.IsNull(OriginalInvoiceData.BillTo.Ins_Id);
+
+        let InvoicePrintData: any = {};
+
+        let argInvoiceData = TrUtils.Stringify(OriginalInvoiceData);
+
+        if (!IncludeGST) {
+            if (argInvoiceData.Settings.Tax === 'TI') {
+                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(argInvoiceData.SType)) {
+            SType = argInvoiceData.SType
+        }
+
+        InvoicePrintData = GetPrintConditionsBasedOnInput(InvoicePrintData, IncludeGST, ConsolidateGST, ForInsurance,
+            SType, argInvoiceData, IsProforma, PartsPrint, LaborPrint);
+
+        InvoicePrintData.Entity = PrintSharedService.GetFormattedEntityDataForPrint(OriginalEntityData, "Invoice", OriginalInvoiceData);
+
+        InvoicePrintData = PrintSharedService.GetEntityHeaderStyles(InvoicePrintData, OriginalEntityData, image);
+
+        InvoicePrintData = GetInvoiceOtherDetailsForPrint(InvoicePrintData, argInvoiceData);
+
+        let IsTaxable: boolean = (IncludeGST && TrUtils.isTaxable(argInvoiceData.Settings.Tax)) ? true : false;
+
+        let finalTotalsData: any = InvoiceTotalsService.GetTotalsValue(argInvoiceData.Ops, argInvoiceData.Items, IsTaxable,
+            true, argInvoiceData.LDisc, argInvoiceData.LPerc, argInvoiceData.PDisc, argInvoiceData.PPerc,
+            argInvoiceData.Disc, argInvoiceData.Perc, TaxCodes, true, argInvoiceData.Settings, argInvoiceData.Adjust, InvoicePrintData.Entity.Round, InvoicePrintData.Entity);
+
+        if (ConsolidateGST) {
+            finalTotalsData.CustLaborTotalBeforeDisc = finalTotalsData.CustLaborAfterTax;
+            finalTotalsData.CustPartsTotalBeforeDisc = finalTotalsData.CustPartAfterTax;
+        }
+
+        InvoicePrintData = TrUtils.ConcatObjects(InvoicePrintData, finalTotalsData);
+
+        InvoicePrintData.Ops = GetLaborPrintInfo(InvoicePrintData.Ops, ConsolidateGST, TaxCodes, OriginalEntityData.Entity.Settings?.Acc?.LTot, InvoicePrintData.Entity.DecimalsNumber);
+
+        InvoicePrintData.Items = GetItemsPrintInfo(InvoicePrintData.Items, ConsolidateGST, TaxCodes, OriginalEntityData.Entity.Settings?.Acc?.LTot, InvoicePrintData.Entity.DecimalsNumber);
+
+        argInvoiceData = ReverseItemsForInvoicePrint(argInvoiceData);
+
+        InvoicePrintData.PrintInfo = PrepareFormatForInvoicePrint(InvoicePrintData, ROTypeEnum.Invoice, argInvoiceData.Sts);
+
+        InvoicePrintData = GetFormattedProductDataForPrint(argInvoiceData, InvoicePrintData);
+
+        InvoicePrintData = GetBillNameForInvoicePrint(argInvoiceData, InvoicePrintData);
+
+        let PaymentData = GetPaymentsTotal(argInvoiceData.Credits, argInvoiceData.Payments, argInvoiceData.Total, argInvoiceData.Sts, InvoicePrintData.Entity.DecimalsNumber);
+        // if (argInvoiceData.Settings.DiscLvl !== 'REC') {
+        //     InvoicePrintData.FixedDisc = null;
+        // }
+        InvoicePrintData.Due = PaymentData.Due;
+        InvoicePrintData.Paid = argInvoiceData.Receipt ? argInvoiceData.Total : PaymentData.Paid;
+        if (!TrUtils.IsNull(PaymentData.Sts)) {
+            InvoicePrintData.Sts = PaymentData.Sts;
+        }
+        InvoicePrintData.Consolidate = ConsolidateGST;
+        InvoicePrintData.ShowDiscountColumn = false;
+        if (!ForInsurance && !ConsolidateGST) {
+            if (PrintSharedService.CheckItemIndexWithDisc(InvoicePrintData) !== -1) {
+                // InvoicePrintData.ShowDiscountColumn = (InvoicePrintData.Settings.DiscLvl === 'ITM' || InvoicePrintData.Settings.DiscLvl === 'RECITM') ? true : false;
+                InvoicePrintData.ShowDiscountColumn = true;
+            }
+        }
+        if (OriginalInvoiceData.Type === '1') {
+            InvoicePrintData.From = 'Sales';
+        }
+
+        if (OriginalInvoiceData.isCountersale) {
+            InvoicePrintData.From = 'Countersale';
+        }
+
+        if (TrUtils.IsNull(OriginalInvoiceData.BL)) {
+            OriginalInvoiceData.BL = {};
+        }
+
+        InvoicePrintData.BL = TrUtils.Stringify(OriginalInvoiceData.BL);
+        OriginalInvoiceData.BL.RefNo = OriginalInvoiceData.RefNo;
+        // console.log('InvoicePrintData', InvoicePrintData);
+
+        return InvoicePrintData;
+    }
+
+export function GetPrintConditionsBasedOnInput(InvoicePrintData: any, IncludeGST: boolean, ConsolidateGST: boolean,
+        ForInsurance: boolean, SType: any, OriginalInvoiceData: any, IsProforma: boolean, PartsPrint: boolean, LaborPrint: boolean) {
+
+        InvoicePrintData.ForInsurance = ForInsurance;
+        InvoicePrintData.For = ForInsurance ? PayTypeEnum.Insurance : PayTypeEnum.Customer;
+        InvoicePrintData.IncludeGST = IncludeGST;
+        InvoicePrintData.ConsolidateGST = ConsolidateGST;
+
+        InvoicePrintData.ShowAccParts = true;
+
+        InvoicePrintData.ShowIGST = (TrUtils.IsNull(SType) || (SType === 'Intra')) ? false : true;
+
+        InvoicePrintData.ShowTaxColumn = (IncludeGST && !ConsolidateGST) ? true : false;
+        // InvoicePrintData.ShowDiscountColumn = (!ForInsurance && !ConsolidateGST) ? true : false;
+
+        InvoicePrintData = GetInvoiceTypeHeading(InvoicePrintData, OriginalInvoiceData, IncludeGST, ConsolidateGST, IsProforma, PartsPrint, LaborPrint);
+
+        InvoicePrintData.PrDate = TrUtils.IsNull(OriginalInvoiceData.PrDate) ? '' : MyDate.ConvertUTCDateToReadable(OriginalInvoiceData.PrDate);
+
+        return InvoicePrintData;
+    }
+
+export function GetInvoiceTypeHeading(InvoicePrintData: any, OriginalInvoiceData: any, IncludeGST: boolean,
+        ConsolidateGST: boolean, IsProforma: boolean, PartsPrint: boolean, LaborPrint: boolean) {
+        // console.log(IsProforma,PartsPrint,LaborPrint);
+        if (OriginalInvoiceData.CheckParts) {
+            InvoicePrintData.HeaderName = "Spares Issue";
+        } else if (OriginalInvoiceData.isCountersale) {
+            InvoicePrintData.HeaderName = 'Counter Sale Invoice';
+        } else if (IsProforma) {
+            // InvoicePrintData.HeaderName = 'PRO-FORMA INVOICE';
+            if (PartsPrint && !LaborPrint) {
+                InvoicePrintData.HeaderName = 'PRO-FORMA INVOICE (PARTS)';
+            } else if (LaborPrint && !PartsPrint) {
+                InvoicePrintData.HeaderName = 'PRO-FORMA INVOICE (LABOR)';
+            } else {
+                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';
+                if (InvoicePrintData.Settings.Tax === 'BS' || ConsolidateGST) {
+                    InvoicePrintData.HeaderName = 'BILL OF SUPPLY';
+                } else {
+                    if (InvoicePrintData.Settings.Tax === 'TI') {
+                        InvoicePrintData.HeaderName = 'PARTS TAX INVOICE';
+                    } else {
+                        InvoicePrintData.HeaderName = 'PARTS INVOICE';
+                    }
+                }
+            } else {
+                // if (IncludeGST && !ConsolidateGST) {
+                //     InvoicePrintData.HeaderName = 'Tax Invoice';
+                // } else {
+                //     InvoicePrintData.HeaderName = 'Invoice';
+                // }
+
+                if (InvoicePrintData.Settings.Tax === 'BS') {
+                    // InvoicePrintData.HeaderName = 'BILL OF SUPPLY';
+                    if (PartsPrint && !LaborPrint) {
+                        InvoicePrintData.HeaderName = 'BILL OF SUPPLY (PARTS)';
+                    } else if (LaborPrint && !PartsPrint) {
+                        InvoicePrintData.HeaderName = 'BILL OF SUPPLY (LABOR)';
+                    } else {
+                        InvoicePrintData.HeaderName = 'BILL OF SUPPLY';
+                    }
+                } else {
+                    if (InvoicePrintData.Settings.Tax === 'TI') {
+                        if (OriginalInvoiceData.Receipt) {
+                            InvoicePrintData.HeaderName = 'TAX SALES RECEIPT';
+                        } else {
+                            if (PartsPrint && !LaborPrint) {
+                                InvoicePrintData.HeaderName = 'TAX INVOICE (PARTS)';
+                            } else if (LaborPrint && !PartsPrint) {
+                                InvoicePrintData.HeaderName = 'TAX INVOICE (LABOR)';
+                            } else {
+                                InvoicePrintData.HeaderName = 'TAX INVOICE';
+                            }
+
+                        }
+
+                    } else {
+                        if (OriginalInvoiceData.Receipt) {
+                            InvoicePrintData.HeaderName = 'SALES RECEIPT';
+
+                        } else {
+                            // InvoicePrintData.HeaderName = 'INVOICE';
+                            if (PartsPrint && !LaborPrint) {
+                                InvoicePrintData.HeaderName = 'INVOICE (PARTS)';
+                            } else if (LaborPrint && !PartsPrint) {
+                                InvoicePrintData.HeaderName = 'INVOICE (LABOR)';
+                            } else {
+                                InvoicePrintData.HeaderName = 'INVOICE';
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return InvoicePrintData;
+    }
+
+export function GetInvoiceOtherDetailsForPrint(InvoicePrintData: any, argInvoiceData: any) {
+        InvoicePrintData.Type = argInvoiceData.isCountersale ? 'SalesReceipt' : argInvoiceData.CheckParts ? 'Work Order' : 'Invoice';
+        InvoicePrintData._id = argInvoiceData.Code;
+        InvoicePrintData.ROCode = argInvoiceData.OrdCode;
+        InvoicePrintData.ROCode = argInvoiceData.OrdCode;
+        InvoicePrintData.TypeName = argInvoiceData.TypeName;
+        InvoicePrintData.Sts = argInvoiceData.Sts;
+        InvoicePrintData.AdmNo = argInvoiceData.AdmNo;
+        InvoicePrintData.CrDate = MyDate.ConvertUTCDateToReadable(argInvoiceData.CrDate);
+        return InvoicePrintData;
+    }
+
+export function GetTaxAmountFromTaxes(item: any, taxCode: string) {
+        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 0;
+    }
+
+export function GetTaxRateFromTaxes(item: any, taxCode: string) {
+        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 0;
+    }
+
+export function 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;
+    }
+
+export function GetLaborPrintInfo(LaborList: any, Consolidate: boolean, TaxCodes: any, LineTotal: string, DecimalsNumber: number) {
+        LaborList.forEach((Labor: any) => {
+            Labor.HSN = Labor.SAC;
+            if (TrUtils.IsNull(Labor.Qty)) {
+                Labor.Qty = 1;
+            }
+            if (Consolidate) {
+                Labor.UnPr = TrUtils.FixedTo(Labor.AfterLaborTax, DecimalsNumber);
+            } else {
+                Labor.UnPr = TrUtils.FixPriceValue(Labor.Pr, DecimalsNumber);
+            }
+            if (!TrUtils.IsEmpty(Labor.Perc)) {
+                Labor.DiscPerc = Labor.Perc;
+            } else {
+                Labor.DiscPerc = Labor.Perc;
+                if (!TrUtils.IsZero(Number(Labor.UnPr))) {
+                    Labor.DiscPerc = Divide(Multiply(100, Labor.Disc), Labor.UnPr);
+                } else {
+                    Labor.DiscPerc = 0;
+                }
+            }
+            Labor.TCode = GetTCodeFromTaxes(Labor);
+            Labor.CGSTAmt = TrUtils.FixPriceValue(GetTaxAmountFromTaxes(Labor, 'CGST'), DecimalsNumber);
+            Labor.SGSTAmt = TrUtils.FixPriceValue(GetTaxAmountFromTaxes(Labor, 'SGST'), DecimalsNumber);
+            Labor.IGSTAmt = TrUtils.FixPriceValue(GetTaxAmountFromTaxes(Labor, 'IGST'), DecimalsNumber);
+            Labor.QtyAndUoM = Labor.Qty.toString();
+            Labor.CGSTPerc = GetTaxRateFromTaxes(Labor, 'CGST');
+            Labor.SGSTPerc = GetTaxRateFromTaxes(Labor, 'SGST');
+            Labor.IGSTPerc = GetTaxRateFromTaxes(Labor, 'IGST');
+            Labor.TaxName = getTaxName(Labor.TCode, TaxCodes);
+            if (LineTotal === 'AT') {
+                Labor.LineTotal = TrUtils.FixPriceValue(Labor.AfterLaborTax, DecimalsNumber);
+            } else {
+                Labor.LineTotal = TrUtils.FixPriceValue(Subtract(Labor.Amt, Labor.Disc), DecimalsNumber);
+            }
+        });
+        return LaborList;
+    }
+
+export function 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(GetTaxAmountFromTaxes(Item, 'CGST'), Item.Qty);
+                let STaxAmtPerItem = Divide(GetTaxAmountFromTaxes(Item, 'SGST'), Item.Qty);
+                let ITaxAmtPerItem = Divide(GetTaxAmountFromTaxes(Item, 'IGST'), Item.Qty);
+                Item.UnPr = TrUtils.FixedTo(Add(AfterDiscForEach, CTaxAmtPerItem, STaxAmtPerItem, ITaxAmtPerItem), DecimalsNumber);
+            } else {
+                Item.UnPr = TrUtils.FixPriceValue(Item.UnPr, DecimalsNumber);
+            }
+
+            // let Index = Item['Desc'].indexOf('#{');
+            // if (Index !== -1) {
+            //     Item.Desc1 = Item['Desc'].substring(Item['Desc'].indexOf('#{') + 2,
+            //         Item['Desc'].lastIndexOf('}#'));
+            // }
+            // Item.Desc = Item['Desc'].split(' #{')[0];
+            Item.MRP = TrUtils.FixPriceValue(Item.MRP, DecimalsNumber);
+            Item.TCode = GetTCodeFromTaxes(Item);
+            Item.CGSTAmt = TrUtils.FixPriceValue(GetTaxAmountFromTaxes(Item, 'CGST'), DecimalsNumber);
+            Item.SGSTAmt = TrUtils.FixPriceValue(GetTaxAmountFromTaxes(Item, 'SGST'), DecimalsNumber);
+            Item.IGSTAmt = TrUtils.FixPriceValue(GetTaxAmountFromTaxes(Item, 'IGST'), DecimalsNumber);
+            Item.TaxName = getTaxName(Item.TCode, TaxCodes);
+            if (!TrUtils.IsEmpty(Item.Perc)) {
+                Item.DiscPerc = Item.Perc;
+            } else {
+                Item.DiscPerc = Item.Perc;
+                if (!TrUtils.IsZero(Number(Item.UnPr))) {
+                    Item.DiscPerc = Divide(Multiply(100, Item.Disc), Item.UnPr);
+                } else {
+                    Item.DiscPerc = 0;
+                }
+            }
+            Item.CGSTPerc = GetTaxRateFromTaxes(Item, 'CGST');
+            Item.SGSTPerc = GetTaxRateFromTaxes(Item, 'SGST');
+            Item.IGSTPerc = GetTaxRateFromTaxes(Item, 'IGST');
+            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;
+            } else {
+                Item.QtyAndUoM = Item.Qty + '';
+            }
+            if (!TrUtils.IsZero(Item.OfQty) && !TrUtils.CheckInvalidSelect(Item.UoM)) {
+                Item.OfQtyAndUoM = Item.OfQty + ' ' + Item.UoM;
+            } else {
+                Item.OfQtyAndUoM = Item.OfQty + '';
+            }
+        });
+        return Items;
+    }
+
+export function getTaxName(TCode: any, TaxCodes: any) {
+        let Index: any = TaxCodes.findIndex((TaxCode: any) => {
+            return Number(TCode) === TaxCode._id;
+        });
+        return (Index !== -1) ? TaxCodes[Index].Name : '';
+    }
+
+export function ReverseItemsForInvoicePrint(argInvoiceData: any) {
+        argInvoiceData.Ops = argInvoiceData.Ops;
+        argInvoiceData.Items = argInvoiceData.Items;
+        return argInvoiceData;
+    }
+
+export function 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;
+    }
+
+export function GetFormattedProductDataForPrint(argInvoiceData: any, InvoicePrintData: any) {
+        if (!TrUtils.IsNull(argInvoiceData.Prod)) {
+            InvoicePrintData.Product = argInvoiceData.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 = argInvoiceData.Prod.MIn;
+            InvoicePrintData.MOut = argInvoiceData.Prod.MOut;
+        }
+        return InvoicePrintData;
+    }
+
+export function GetBillNameForInvoicePrint(argInvoiceData: any, InvoicePrintData: any) {
+        let Customer: any = {};
+        if (!TrUtils.IsNull(argInvoiceData.BillTo)) {
+            Customer.Name = argInvoiceData.BillTo.Name;
+            if (!TrUtils.IsNull(argInvoiceData.BillTo.Sltn)) {
+                Customer.Name = argInvoiceData.BillTo.Sltn + ' ' + Customer.Name;
+            }
+            Customer.Code = argInvoiceData.Cust?.Code;
+            Customer.Adrs = [];
+            Customer.Cons = [];
+            if (!TrUtils.IsNull(argInvoiceData.BillTo.Adrs)) {
+                Customer.Adrs.push(argInvoiceData.BillTo.Adrs.A1);
+                if (!TrUtils.IsEmpty(argInvoiceData.BillTo.Adrs.A2)) {
+                    Customer.Adrs.push(argInvoiceData.BillTo.Adrs.A2);
+                }
+                if (!TrUtils.IsEmpty(argInvoiceData.BillTo.Adrs.Ct)) {
+                    let city: any = argInvoiceData.BillTo.Adrs.Ct;
+                    if (!TrUtils.IsEmpty(argInvoiceData.BillTo.Adrs.Pin)) {
+                        city = city + ', ' + argInvoiceData.BillTo.Adrs.StCode + '-' + argInvoiceData.BillTo.Adrs.Pin;
+                    }
+                    Customer.Adrs.push(city);
+                }
+            }
+            Customer.GSTIN = argInvoiceData.BillTo.GSTIN;
+            if (!TrUtils.IsNull(argInvoiceData.BillTo.DLNo)) {
+                Customer.DLNo = argInvoiceData.BillTo.DLNo;
+            }
+
+            if (!TrUtils.IsEmpty(argInvoiceData.BillTo.Ph)) {
+                Customer.Cons = [
+                    {
+                        Type: 'M',
+                        No: argInvoiceData.BillTo.Ph
+                    }
+                ];
+            }
+            InvoicePrintData.Customer = Customer;
+            InvoicePrintData.Name = argInvoiceData.Name;
+
+            if (!TrUtils.IsNull(argInvoiceData.BillTo.Ins_Id)) {
+                InvoicePrintData.Cust = GetCustomerDetails(argInvoiceData);
+            }
+        } else if (!TrUtils.IsNull(argInvoiceData.Cust)) {
+            Customer.Name = argInvoiceData.Cust.Name;
+            Customer.Code = argInvoiceData.Cust.Code;
+            Customer.Adrs = [];
+            Customer.Cons = [];
+            InvoicePrintData.Customer = Customer;
+        }
+
+
+        if (!TrUtils.IsNull(argInvoiceData.ShipTo)) {
+            let location: any = {};
+            location.Adrs = PrintSharedService.GetAddress(argInvoiceData.ShipTo.Adrs);
+            let Name: any;
+            if (TrUtils.IsNull(argInvoiceData.ShipTo.Name)) {
+                Name = argInvoiceData.ShipTo.ConName;
+            } else {
+                Name = argInvoiceData.ShipTo.Name;
+            }
+            if (TrUtils.IsNull(Name)) {
+                Name = '';
+            }
+            location.Name = Name;
+            if (!TrUtils.IsNull(argInvoiceData.ShipTo.ConPh)) {
+                location.Cons = [
+                    {
+                        Type: 'M',
+                        No: argInvoiceData.ShipTo.ConPh
+                    }
+                ];
+            }
+
+            InvoicePrintData.Location = location;
+        }
+        return InvoicePrintData;
+    }
+
+export function GetCustomerDetails(argInvoiceData: any) {
+        let Customer: any = {};
+        Customer.Name = GetBillToName(argInvoiceData.Cust.Title, argInvoiceData.Cust.Name);
+        Customer.Cons = [];
+        if (!TrUtils.IsEmpty(argInvoiceData.Cust.Ph)) {
+            Customer.Cons = [
+                {
+                    Type: 'M',
+                    No: argInvoiceData.Cust.Ph
+                }
+            ];
+        }
+        Customer.GSTIN = argInvoiceData.Cust.GSTIN;
+        Customer.Adrs = [];
+        if (!TrUtils.IsNull(argInvoiceData.Cust.Adrs)) {
+            Customer.Adrs.push(argInvoiceData.Cust.Adrs.A1);
+            if (!TrUtils.IsEmpty(argInvoiceData.Cust.Adrs.A2)) {
+                Customer.Adrs.push(argInvoiceData.Cust.Adrs.A2);
+            }
+            Customer.Adrs.push(argInvoiceData.Cust.Adrs.Ct);
+        }
+        Customer.ConName = argInvoiceData.Cust.ConName;
+        Customer.ConPh = argInvoiceData.Cust.ConPhone;
+        return Customer;
+    }
+
+export function GetBillToName(Title: any, Name: string) {
+        return TrUtils.IsEmpty(Title) ? Name : Title + ' ' + Name;
+    }
+
+export function GetPaymentsTotal(Credits: any, InvoicePayments: any, Total: number, InvoiceStatus: string, DecimalsNumber: number) {
+        var i = 0;
+        let Data: any = {};
+        let PaidTotal: any = 0;
+        if (TrUtils.IsNull(InvoicePayments)) {
+            InvoicePayments = [];
+        }
+        if (TrUtils.IsNull(Credits)) {
+            Credits = [];
+        }
+        for (i = 0; i < InvoicePayments.length; i++) {
+            PaidTotal += InvoicePayments[i].Paid;
+        }
+        for (i = 0; i < Credits.length; i++) {
+            PaidTotal += Credits[i].Amt;
+        }
+        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;
+    }