shareneus 1.0.5

package/dist/services/technician-pdf.service.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TechnicianpdfService = void 0;
+const enums_1 = require("../enums/enums");
+const tr_utils_1 = require("../utils/tr-utils");
+const shared_pdf_service_1 = require("./shared-pdf.service");
+class TechnicianpdfService {
+    static GetTechnicianPrint(RepairOrder, isOtherIndustry) {
+        var dd = {
+            info: {
+                title: 'Technician',
+            },
+            header: function (currentPage, pageCount) {
+                return { text: currentPage.toString() + ' of ' + pageCount, alignment: 'right', marginRight: 7, fontSize: 8, marginTop: 2 };
+            },
+            pageMargins: [10, 15, 10, 15],
+            content: [
+                // SharedPDFService.MainHeading(RepairOrder.Entity.CName, RepairOrder.Entity.Header, RepairOrder.Image, RepairOrder.HColor, null),
+                shared_pdf_service_1.SharedPDFService.GetMainHeader(RepairOrder.Entity, RepairOrder.Image, RepairOrder.AColor, RepairOrder.HColor, null),
+                shared_pdf_service_1.SharedPDFService.GetPrintType(RepairOrder.HeaderName),
+                shared_pdf_service_1.SharedPDFService.HeaderAfterLine(),
+                shared_pdf_service_1.SharedPDFService.GetCustomerAndVehicleDetails(RepairOrder._id, RepairOrder.CrDate, RepairOrder.PrDate, RepairOrder.MOut, RepairOrder.MIn, RepairOrder.Product, RepairOrder.PrintType, RepairOrder.For, RepairOrder.SurName, RepairOrder.SurPhone, RepairOrder.Type, RepairOrder.SurEmail, RepairOrder.InsComp, RepairOrder.PolNo, RepairOrder.PolType, RepairOrder.Customer, false, RepairOrder.Settings, null, isOtherIndustry, null, null, null, null),
+                shared_pdf_service_1.SharedPDFService.CustomerAndVehicleDetailsAfterLine(),
+                { stack: this.getComplaintsAndServices(RepairOrder.Comps, RepairOrder.Ops), marginBottom: 7 },
+                this.getLine(RepairOrder.Comps),
+                this.getOnlyServices(RepairOrder.Ops),
+                this.GetIndHeading(RepairOrder.Colli),
+                this.GetCollisionItems(RepairOrder.Colli, RepairOrder.Parts, RepairOrder.Ops),
+            ],
+            styles: shared_pdf_service_1.SharedPDFService.GetStyles()
+        };
+        return dd;
+        // pdfMake.createPdf(dd).open();
+        // this.dd = TrUtils.Stringify(dd);
+        // pdfMake.createPdf(dd).getDataUrl(function (outDoc: any) {
+        //     document.getElementById('pdf').setAttribute('src', outDoc);
+        // });
+    }
+    static GetIndHeading(CollItems) {
+        if (!tr_utils_1.TrUtils.IsNull(CollItems) && CollItems.length !== 0) {
+            return [{ text: 'Accidental Repairs :', fontSize: 12, marginTop: 5, bold: true, decoration: 'underline' }];
+        }
+        else {
+            let a = {};
+            return a;
+        }
+    }
+    static getLine(Comps) {
+        if (Comps.length !== 0) {
+            return shared_pdf_service_1.SharedPDFService.GetUnderLine();
+        }
+        else {
+            let a = {};
+            return a;
+        }
+    }
+    static GetCollisionItems(CollItems, Parts, Labors) {
+        if (!tr_utils_1.TrUtils.IsNull(CollItems) && CollItems.length !== 0) {
+            return {
+                style: 'tableExample',
+                marginTop: 10,
+                lineHeight: 1,
+                table: {
+                    widths: [20, 300, 20, 60, 60, 60],
+                    // headerRows: 1,
+                    body: this.GetCollisionItemsBody(CollItems, Parts, Labors)
+                },
+                layout: {
+                    hLineColor: function (i, node) {
+                        return 'lightgray';
+                    },
+                    vLineColor: function (i, node) {
+                        return 'lightgray';
+                    },
+                }
+            };
+        }
+        else {
+            let a = {};
+            return a;
+        }
+    }
+    static GetCollisionItemsBody(CollItems, Parts, Labors) {
+        var body = [];
+        let columns = this.GetCollisionItemsHeader();
+        body.push(columns);
+        let SNo = 1;
+        CollItems.forEach((CollItem, i) => {
+            var dataRow = [];
+            columns.forEach((column) => {
+                if (column.Field === 'SNo') {
+                    CollItem[column.Field] = SNo;
+                    SNo = SNo + 1;
+                }
+                else if (column.Field === 'Desc') {
+                    CollItem[column.Field] = CollItem.Desc;
+                }
+                else if (column.Field === 'rr') {
+                    let CollLaborIndex = Labors.findIndex((Labor) => {
+                        return Labor._id === CollItem.RRFId;
+                    });
+                    if (CollLaborIndex !== -1) {
+                        CollItem[column.Field] = this.CheckPrice(Labors[CollLaborIndex]);
+                    }
+                    else {
+                        CollItem[column.Field] = '';
+                    }
+                }
+                else if (column.Field === 'dtng') {
+                    let CollLaborIndex = Labors.findIndex((Labor) => {
+                        return Labor._id === CollItem.RepId;
+                    });
+                    if (CollLaborIndex !== -1) {
+                        CollItem[column.Field] = this.CheckPrice(Labors[CollLaborIndex]);
+                    }
+                    else {
+                        CollItem[column.Field] = '';
+                    }
+                }
+                else if (column.Field === 'ptng') {
+                    let CollLaborIndex = Labors.findIndex((Labor) => {
+                        return Labor._id === CollItem.PainId;
+                    });
+                    if (CollLaborIndex !== -1) {
+                        CollItem[column.Field] = this.CheckPrice(Labors[CollLaborIndex]);
+                    }
+                    else {
+                        CollItem[column.Field] = '';
+                    }
+                }
+                else if (column.Field === 'Qty') {
+                    let CollPartIndex = Parts.findIndex((Part) => {
+                        return Part.CollId === CollItem._id;
+                    });
+                    if (CollPartIndex !== -1) {
+                        CollItem[column.Field] = Parts[CollPartIndex][column.Field];
+                    }
+                    else {
+                        CollItem[column.Field] = '';
+                    }
+                }
+                else {
+                    CollItem[column.Field] = '';
+                }
+                if (column.Field === 'Desc') {
+                    let DescData = [];
+                    DescData.push(CollItem[column.Field].toString());
+                    if (!tr_utils_1.TrUtils.IsEmpty(CollItem['EDesc'])) {
+                        DescData.push({ text: CollItem['EDesc'].toString(), color: 'grey' });
+                    }
+                    dataRow.push({ stack: DescData });
+                }
+                else {
+                    dataRow.push({ text: CollItem[column.Field].toString(), alignment: 'center' });
+                }
+            });
+            body.push(dataRow);
+        });
+        return body;
+    }
+    static CheckPrice(Labor) {
+        if (Labor.PBy === enums_1.PayTypeEnum.Insurance) {
+            if (!tr_utils_1.TrUtils.IsZero(Labor.AssPr)) {
+                return 'Yes';
+            }
+            else {
+                return '';
+            }
+        }
+        if (Labor.PBy === enums_1.PayTypeEnum.Customer) {
+            if (!tr_utils_1.TrUtils.IsZero(Labor.Pr)) {
+                return 'Yes';
+            }
+            else {
+                return '';
+            }
+        }
+        if (Labor.PBy === enums_1.PayTypeEnum.Shared) {
+            if (!tr_utils_1.TrUtils.IsZero(Labor.AssPr) && !tr_utils_1.TrUtils.IsZero(Labor.Pr)) {
+                return 'Yes';
+            }
+            else {
+                return '';
+            }
+        }
+    }
+    static GetCollisionItemsHeader() {
+        let headersNames = [{ text: 'S.No.', Field: 'SNo', style: ['tableheader', 'withOutApp'] },
+            { text: 'Description', Field: 'Desc', style: ['tableheader', 'withOutApp'] },
+            { text: 'Qty', Field: 'Qty', style: ['tableheader', 'withOutApp'] },
+            { text: 'R&R', Field: 'rr', style: ['tableheader', 'withOutApp'] },
+            { text: 'Denting', Field: 'dtng', style: ['tableheader', 'withOutApp'] },
+            { text: 'Painting', Field: 'ptng', style: ['tableheader', 'withOutApp'] }];
+        return headersNames;
+    }
+    static getComplaintsAndServices(Comps, Ops) {
+        var List = [];
+        if (!tr_utils_1.TrUtils.IsNull(Comps) && Comps.length !== 0) {
+            List.push({ text: 'Complaints :', fontSize: 12, marginTop: 5, bold: true, decoration: 'underline' });
+            for (var i = 0; i < Comps.length; i++) {
+                List.push({ ul: [{ text: Comps[i].Desc, fontSize: 10, bold: true, marginLeft: 10, marginTop: 5 }] });
+                for (var j = 0; j < Ops.length; j++) {
+                    if (Comps[i]._id === Ops[j].CompId) {
+                        List.push({ text: Ops[j].Desc, fontSize: shared_pdf_service_1.SharedPDFService.TableHeaders, marginTop: 1.5, marginLeft: 30 });
+                    }
+                }
+            }
+            return List;
+        }
+        else {
+            return List;
+        }
+    }
+    static getOnlyServices(Ops) {
+        let List = [];
+        let isTrue = false;
+        if (!tr_utils_1.TrUtils.IsNull(Ops) && Ops.length !== 0) {
+            for (var i = 0; i < Ops.length; i++) {
+                if (tr_utils_1.TrUtils.IsNull(Ops[i].CompId) && tr_utils_1.TrUtils.IsNull(Ops[i].CollId)) {
+                    isTrue = true;
+                    List.push({ ul: [{ text: Ops[i].Desc, fontSize: 10, bold: true, marginLeft: 10, marginTop: 5 }] });
+                }
+            }
+            if (isTrue) {
+                List.unshift({ text: 'Services :', fontSize: 12, marginTop: 5, bold: true, decoration: 'underline' });
+            }
+            return List;
+        }
+        else {
+            return this.EmptyReturnValue();
+        }
+    }
+    static EmptyReturnValue() {
+        let Empty = '';
+        return Empty;
+    }
+}
+exports.TechnicianpdfService = TechnicianpdfService;

package/dist/services/technician-print.service.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TechnicianPrintService = void 0;
+const enums_1 = require("../enums/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");
+class TechnicianPrintService {
+    static GetTechnicianPrintData(OriginalROData, OriginalCustomerData, OriginalVehicleData, EntityData, image) {
+        let TechnicianPrintData = {};
+        TechnicianPrintData.Entity = shared_print_service_1.PrintSharedService.GetFormattedEntityDataForPrint(EntityData, "Technician Copy", OriginalROData);
+        TechnicianPrintData = shared_print_service_1.PrintSharedService.GetEntityHeaderStyles(TechnicianPrintData, EntityData, image);
+        if (tr_utils_1.TrUtils.IsNull(OriginalROData.Comps)) {
+            OriginalROData.Comps = [];
+        }
+        if (tr_utils_1.TrUtils.IsNull(OriginalROData.Ops)) {
+            OriginalROData.Ops = [];
+        }
+        if (tr_utils_1.TrUtils.IsNull(OriginalROData.Parts)) {
+            OriginalROData.Parts = [];
+        }
+        if (tr_utils_1.TrUtils.IsNull(OriginalROData.Colli)) {
+            OriginalROData.Colli = [];
+        }
+        // Gets ROData From Service And Filters Only Valid Data
+        let argROData = tr_utils_1.TrUtils.Stringify(OriginalROData);
+        argROData = this.GetItemsForTechnicianPrint(argROData);
+        argROData = this.ReverseItemsForTechnicianPrint(argROData);
+        TechnicianPrintData.Comps = argROData.Comps;
+        TechnicianPrintData.Ops = argROData.Ops;
+        TechnicianPrintData.Parts = argROData.Parts;
+        TechnicianPrintData.Colli = argROData.Colli;
+        // Prepare Records Description In A Readable Format
+        // TechnicianPrintData.Comps = PrintSharedService.FilterRecordsDescription(TechnicianPrintData.Comps);
+        // TechnicianPrintData.Ops = PrintSharedService.FilterRecordsDescription(TechnicianPrintData.Ops);
+        // TechnicianPrintData.Parts = PrintSharedService.FilterRecordsDescription(TechnicianPrintData.Parts);
+        // TechnicianPrintData.Colli = PrintSharedService.FilterRecordsDescription(TechnicianPrintData.Colli);
+        TechnicianPrintData.PrDate = my_date_1.MyDate.ConvertUTCDateToReadable(argROData.PrDate);
+        TechnicianPrintData.CrDate = my_date_1.MyDate.ConvertUTCDateToReadable(argROData.CrDate);
+        TechnicianPrintData.MIn = OriginalVehicleData.MIn;
+        TechnicianPrintData.Product = shared_print_service_1.PrintSharedService.GetVehicleFromServiceAndFormatData(OriginalVehicleData);
+        TechnicianPrintData.Customer = shared_print_service_1.PrintSharedService.GetCustomerDataForTechnicianPrint(OriginalCustomerData);
+        TechnicianPrintData._id = argROData.Code;
+        TechnicianPrintData.Type = 'Technician Copy';
+        TechnicianPrintData.HeaderName = 'Technician Copy';
+        TechnicianPrintData.For = 'Technician';
+        return TechnicianPrintData;
+    }
+    static GetItemsForTechnicianPrint(argROData) {
+        if (argROData.Sts === enums_1.ROStatusEnum.New || argROData.Sts === enums_1.ROStatusEnum.WtngForAppr) {
+            argROData.Ops.forEach((Labor) => {
+                Labor.Sts = enums_1.LaborStatusEnum.New;
+            });
+            argROData.Parts.forEach((Part) => {
+                if (!tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                    Part.Sts = enums_1.LaborStatusEnum.New;
+                }
+            });
+            argROData.Colli.forEach((Collision) => {
+                Collision.Sts = enums_1.LaborStatusEnum.New;
+            });
+        }
+        argROData.Ops = argROData.Ops.filter((Labor) => {
+            return Labor.Sts !== enums_1.LaborStatusEnum.Cancelled && Labor.Sts !== enums_1.LaborStatusEnum.Declined;
+        });
+        argROData.Parts = argROData.Parts.filter((Part) => {
+            if (!tr_utils_1.TrUtils.IsNull(Part.CollId)) {
+                return Part.Sts !== enums_1.LaborStatusEnum.Cancelled && Part.Sts !== enums_1.LaborStatusEnum.Declined;
+            }
+            else {
+                return Part;
+            }
+        });
+        argROData.Colli = argROData.Colli.filter((Collision) => {
+            return Collision.Sts !== enums_1.LaborStatusEnum.Cancelled && Collision.Sts !== enums_1.LaborStatusEnum.Declined;
+        });
+        return argROData;
+    }
+    static ReverseItemsForTechnicianPrint(argROData) {
+        argROData.Comps = argROData.Comps.reverse();
+        argROData.Ops = argROData.Ops.reverse();
+        argROData.Parts = argROData.Parts.reverse();
+        argROData.Colli = argROData.Colli.reverse();
+        return argROData;
+    }
+}
+exports.TechnicianPrintService = TechnicianPrintService;

package/dist/services/transfer-order-pdf.service.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferOrderPrintService = void 0;
+const shared_pdf_service_1 = require("./shared-pdf.service");
+class TransferOrderPrintService {
+    static GetTransferOrderPrint(ReOrderPointData) {
+        // console.log('ReOrderPointData', ReOrderPointData);
+        let dd = {
+            info: {
+                title: 'TransferOrder',
+            },
+            header: function (currentPage, pageCount, pageSize) {
+                return { text: currentPage.toString() + ' of ' + pageCount, alignment: 'right', marginRight: 25, fontSize: 8, marginTop: 2 };
+            },
+            pageMargins: [10, 15, 10, 15],
+            pageSize: 'A4',
+            content: [
+                { text: ReOrderPointData.Entity.CName, style: ['headerstyle'], alignment: 'center', fontSize: 20 },
+                shared_pdf_service_1.SharedPDFService.GetPrintType('Transfer Order'),
+                shared_pdf_service_1.SharedPDFService.HeaderAfterLine(), // { text: 'Reorder Point (' + 'As of ' + MyDate.ConvertUTCDateToReadable(MyDate.GetDateTimeNowInUTC()) + ')', style: ['headerstyle'], alignment: 'center', fontSize: 12 },
+                // { text: 'Items need to be Ordered', style: ['headerstyle'], alignment: 'left', fontSize: 10, marginTop: 10, decoration: 'underline' },
+                { text: 'From :  ' + ReOrderPointData.FromName, style: 'hed', marginTop: 5 },
+                { text: 'To :  ' + ReOrderPointData.ToName, style: 'hed' },
+                { text: 'Date :  ' + ReOrderPointData.Date, style: 'hed', marginBottom: 5 },
+                this.GetItemsTable(ReOrderPointData.Items),
+                this.GetSignatures(ReOrderPointData.Entity.CName, ReOrderPointData.Type, ReOrderPointData.For),
+            ],
+            styles: {
+                headerstyle: {
+                    fontFamily: 'Calibri',
+                    fontSize: 9
+                },
+                Sign: {
+                    fontSize: 8,
+                    margin: [0, 30, 0, 5]
+                },
+                forCompany: {
+                    marginRight: 5,
+                    marginTop: 10,
+                    fontSize: 9,
+                    alignment: 'right'
+                },
+                tableheader: {
+                    bold: true,
+                    fontFamily: 'Calibri',
+                    margin: [0, 1, 0, 5],
+                    alignment: 'center'
+                },
+                tableheader1: {
+                    bold: true,
+                    fontFamily: 'Calibri',
+                    margin: [0, 2, 0, 2],
+                    alignment: 'center'
+                },
+                tableExample: {
+                    fontSize: 9
+                },
+                hed: {
+                    fontSize: 9
+                },
+            }
+        };
+        return dd;
+    }
+    static CustomerAndVehicleDetailsAfterLine() {
+        return {
+            canvas: [
+                {
+                    type: 'line',
+                    lineColor: 'gray',
+                    x1: 0,
+                    y1: 0,
+                    x2: 575,
+                    y2: 0,
+                    lineWidth: 1
+                }
+            ]
+        };
+    }
+    static GetSignatures(CName, For, Type) {
+        return {
+            columns: [{
+                    stack: [
+                        this.CompanyName(CName),
+                    ]
+                }],
+        };
+    }
+    static CompanyName(CName) {
+        return {
+            style: 'forCompany',
+            text: ['For ', { text: CName, }],
+        };
+    }
+    static GetItemsTable(Items) {
+        return {
+            style: 'tableExample',
+            marginTop: 3,
+            marginBottom: 5,
+            table: {
+                widths: ['*', 'auto'],
+                headerRows: 1,
+                body: this.BuildTableBodyForLaborAndParts(Items)
+            },
+            layout: {
+                hLineWidth: function (i, node) {
+                    return (i === 0 || i === 1 || i === node.table.body.length) ? 1 : 0.5;
+                },
+                vLineWidth: function (i, node) {
+                    return (i === 0 || i === node.table.widths.length) ? 1 : 0.5;
+                },
+                hLineColor: function (i, node) {
+                    return (i === 0 || i === 1 || i === node.table.body.length) ? 'gray' : 'lightgrey';
+                },
+                vLineColor: function (i, node) {
+                    return 'gray';
+                },
+            }
+        };
+    }
+    static BuildTableBodyForLaborAndParts(Items) {
+        let body = this.GetHeaderNames();
+        Items.forEach((item, index) => {
+            let dataRow = [];
+            dataRow.push({ text: item.Desc, });
+            dataRow.push({ text: item.Qty, alignment: 'right', style: ['headerstyle'], });
+            body.push(dataRow);
+        });
+        return body;
+    }
+    static GetHeaderNames() {
+        let HeadingNames;
+        HeadingNames = [[{ text: 'Description', style: 'tableheader1', Field: 'Name', alignment: 'left', line: true },
+                { text: 'Quantity', style: 'tableheader1', Field: 'Qty', alignment: 'right' }
+            ]];
+        return HeadingNames;
+    }
+}
+exports.TransferOrderPrintService = TransferOrderPrintService;

package/dist/services/vendor-balances-pdf.service.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VendorBalancesService = void 0;
+const my_date_1 = require("../utils/my-date");
+const tr_utils_1 = require("../utils/tr-utils");
+const shared_pdf_service_1 = require("./shared-pdf.service");
+class VendorBalancesService {
+    static GetVendorBalancesPrint(BillData, CName) {
+        var dd = {
+            info: {
+                title: 'VendorBalances'
+            },
+            header: function (currentPage, pageCount) {
+                return { text: currentPage.toString() + ' of ' + pageCount, alignment: 'right', marginRight: 7, fontSize: 8, marginTop: 2 };
+            },
+            pageMargins: [10, 15, 10, 15],
+            content: [
+                { text: '' + CName + '', style: ['header'] },
+                { text: 'Vendor Balances', alignment: 'center', fontSize: 15, bold: true },
+                { text: 'As of ' + my_date_1.MyDate.ConvertUTCDateToReadable(my_date_1.MyDate.GetDateTimeNowInUTC()),
+                    alignment: 'center', fontSize: 10 },
+                // SharedPDFService.HeaderAfterLine(),
+                this.GetBillDataTable(BillData),
+            ],
+            styles: shared_pdf_service_1.SharedPDFService.GetStyles()
+        };
+        return dd;
+    }
+    static GetBillDataTable(BillData) {
+        let Data = [];
+        let OveralDue = 0;
+        BillData.forEach((bill) => {
+            OveralDue = OveralDue + bill.Balance;
+            Data.push(this.GetItemsTable(bill));
+        });
+        Data.push({
+            style: 'tableExample',
+            table: {
+                widths: [50, '*', 150, 100, 100],
+                body: [[{ text: 'Overall Due ', alignment: 'right', colSpan: 4, bold: true, fontSize: 12, marginRight: 5 }, {}, {}, {}, { text: tr_utils_1.TrUtils.FixPriceValue(OveralDue), fontSize: 12, alignment: 'right', bold: true, marginRight: 5 }]],
+            },
+            layout: 'noBorders'
+        });
+        return Data;
+    }
+    static GetItemsTable(billData) {
+        return {
+            style: 'tableExample',
+            marginTop: 3,
+            marginBottom: 5,
+            table: {
+                widths: [50, '*', 150, 100, 100],
+                headerRows: 2,
+                body: this.BuildTableBodyForLaborAndParts(billData)
+            },
+            layout: {
+                hLineWidth: function (i, node) {
+                    return (i === 0 || i === 1 || i === 2 || i === node.table.body.length - 1 || i === node.table.body.length) ? 1 : 0.5;
+                },
+                vLineWidth: function (i, node) {
+                    return (i === 0 || i === node.table.widths.length) ? 1 : 0.5;
+                },
+                hLineColor: function (i, node) {
+                    return (i === 0 || i === 1 || i === 2 || i === node.table.body.length - 1 || i === node.table.body.length) ? 'gray' : 'lightgrey';
+                },
+                vLineColor: function (i, node) {
+                    return 'gray';
+                },
+            }
+        };
+    }
+    static BuildTableBodyForLaborAndParts(billData) {
+        let body = this.GetHeaderNames();
+        let Row = [{ text: billData.Name, alignment: 'left', colSpan: 5, bold: true, fontSize: 12 }, {}, {}, {}, {}];
+        body.unshift(Row);
+        billData.Bills.forEach((bill, index) => {
+            let dataRow = [];
+            dataRow.push({ text: index + 1 });
+            dataRow.push({ text: bill.BNo });
+            dataRow.push({ text: my_date_1.MyDate.ConvertUTCDateToReadable(bill.CrDate), alignment: 'center', style: ['headerstyle'], });
+            dataRow.push({ text: tr_utils_1.TrUtils.FixPriceValue(bill.Total), alignment: 'right', style: ['headerstyle'], });
+            dataRow.push({ text: tr_utils_1.TrUtils.FixPriceValue(bill.Due), alignment: 'right', style: ['headerstyle'], });
+            body.push(dataRow);
+            if (billData.Bills.length === (index + 1)) {
+                let Row = [{ text: 'Total Due ', alignment: 'right', colSpan: 4, bold: true, fontSize: 12 }, {}, {}, {}, { text: tr_utils_1.TrUtils.FixPriceValue(billData.Balance), fontSize: 12, alignment: 'right', bold: true }];
+                body.push(Row);
+            }
+        });
+        return body;
+    }
+    static GetHeaderNames() {
+        let HeadingNames;
+        HeadingNames = [[{ text: 'S.No', style: 'tableheader1', Field: 'SNo', alignment: 'left', line: true },
+                { text: 'B.No', style: 'tableheader1', Field: 'BNo', alignment: 'left' },
+                { text: 'Create Date', style: 'tableheader1', Field: 'CrDate' },
+                { text: 'Total', style: 'tableheader1', Field: 'Total', alignment: 'right' },
+                { text: 'Due', style: 'tableheader1', Field: 'Due', alignment: 'right' }]];
+        return HeadingNames;
+    }
+}
+exports.VendorBalancesService = VendorBalancesService;