shareneus 1.0.5

package/dist/services/sales-totals.service.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SalesTotalsService = void 0;
+const aggregation_1 = require("../aggregation/aggregation");
+const tr_utils_1 = require("../utils/tr-utils");
+class SalesTotalsService {
+    static GetTotalsValue(ItemsList, IsIndependentTax, DetailedInfo, PDisc, PPerc, Disc, Perc, TaxCodes, WithItems, Settings, isRoundable) {
+        // LPerc = TrUtils.SetPercToStringIfNull(LPerc);
+        PPerc = tr_utils_1.TrUtils.SetPercToStringIfNull(PPerc);
+        Perc = tr_utils_1.TrUtils.SetPercToStringIfNull(Perc);
+        // LDisc = TrUtils.SetValueToZeroIfNull(LDisc);
+        PDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(PDisc);
+        Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Disc);
+        // opCodesList = this.CalculateLaborValues(opCodesList, IsIndependentTax);
+        ItemsList = this.CalculateLaborItemValues(ItemsList, IsIndependentTax);
+        let finalTotalsData = this.GetFinalRODataForSave(ItemsList, IsIndependentTax, PDisc, PPerc, Disc, Perc, DetailedInfo, Settings, isRoundable);
+        if (DetailedInfo) {
+            finalTotalsData = this.GetDetailedTotalsData(finalTotalsData, IsIndependentTax, ItemsList, TaxCodes);
+        }
+        if (WithItems) {
+            finalTotalsData.Items = ItemsList;
+        }
+        return finalTotalsData;
+    }
+    static CalculateLaborItemValues(ItemsList, IsIndependentTax) {
+        ItemsList = this.ResetLaborItemValues(ItemsList, IsIndependentTax);
+        // ItemsList = this.GetLaborItemsDiscountPrice(ItemsList);
+        // ItemsList = this.GetLaborItemsAfterDiscount(ItemsList);
+        // ItemsList = this.GetItemsAfterTax(ItemsList, IsIndependentTax);
+        return ItemsList;
+    }
+    static ResetLaborItemValues(ItemsList, IsIndependentTax) {
+        ItemsList.forEach((Item) => {
+            Item = this.ResetLaborItemValueIfInvalid(Item);
+            Item.DiscountedPrice = (0, aggregation_1.addition)(Item.Disc, Item.RecDisc);
+            Item.AfterItemDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.NetAmt);
+            if (IsIndependentTax) {
+                Item.AfterItemTax = (0, aggregation_1.addition)(Item.AfterItemDisc, Item.CGST, Item.SGST, Item.IGST);
+            }
+            else {
+                Item.AfterItemTax = Item.AfterItemDisc;
+            }
+        });
+        return ItemsList;
+    }
+    static ResetLaborItemValueIfInvalid(Item) {
+        Item.UnPr = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.UnPr);
+        Item.Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.Disc);
+        Item.RecDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.RecDisc);
+        Item.CGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.CGST);
+        Item.SGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.SGST);
+        Item.IGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Item.IGST);
+        return Item;
+    }
+    static GetFinalRODataForSave(ItemsList, IsIndependentTax, PDisc, PPerc, Disc, Perc, DetailedInfo, Settings, isRoundable) {
+        let finalTotalsData = {};
+        finalTotalsData = this.SetMainDiscountValues(PPerc, PDisc, Disc, Perc, finalTotalsData, DetailedInfo);
+        finalTotalsData.Settings = Settings;
+        finalTotalsData = this.GetFinalCustomerTotalsData(finalTotalsData, ItemsList, IsIndependentTax, DetailedInfo, isRoundable);
+        return finalTotalsData;
+    }
+    static SetMainDiscountValues(PPerc, PDisc, Disc, Perc, finalTotalsData, DetailedInfo) {
+        finalTotalsData.PDisc = PDisc;
+        finalTotalsData.PPerc = PPerc;
+        finalTotalsData.Disc = Disc;
+        finalTotalsData.Perc = Perc;
+        if (DetailedInfo) {
+            finalTotalsData.FixedPDisc = PDisc;
+            finalTotalsData.FixedDisc = Disc;
+        }
+        return finalTotalsData;
+    }
+    static GetFinalCustomerTotalsData(finalTotalsData, ItemsList, IsIndependentTax, DetailedInfo, isRoundable) {
+        let CustomerAfterDiscTotals = this.GetSubTotalFor(ItemsList);
+        // let CustLaborTaxTotal = this.GetLaborTaxTotalFor(IsIndependentTax);
+        let CustItemTaxTotal = this.GetItemsTaxTotalFor(ItemsList, IsIndependentTax);
+        let CustItemsDiscTotal = this.GetItemDiscountedTotal(ItemsList);
+        finalTotalsData.SubTotal = (0, aggregation_1.addition)(CustomerAfterDiscTotals, CustItemsDiscTotal);
+        let CustTotal = this.GetCustomerTotalBasedOnTaxType(CustItemTaxTotal, ItemsList, IsIndependentTax);
+        if (isRoundable) {
+            finalTotalsData.Round = (0, aggregation_1.subtraction)(Math.round(CustTotal), CustTotal);
+            finalTotalsData.Total = Math.round(CustTotal);
+        }
+        else {
+            finalTotalsData.Total = tr_utils_1.TrUtils.FixedTo(CustTotal);
+        }
+        if (DetailedInfo) {
+            finalTotalsData.FixedSubTotal = tr_utils_1.TrUtils.FixedTo(CustomerAfterDiscTotals);
+            finalTotalsData.FixedTotal = tr_utils_1.TrUtils.FixedTo(CustTotal);
+        }
+        return finalTotalsData;
+    }
+    static GetSubTotalFor(ItemsList) {
+        // let LaborTotalAfterDisc: any = this.GetLaborTotalAfterDiscount(LaborList);
+        let ItemsTotalAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);
+        return ItemsTotalAfterDisc;
+    }
+    static GetItemsTotalAfterDiscount(ItemsList) {
+        let ItemsTotalAfterDisc = 0;
+        ItemsList.forEach((Item) => {
+            ItemsTotalAfterDisc = (0, aggregation_1.addition)(ItemsTotalAfterDisc, Item.AfterItemDisc);
+        });
+        return ItemsTotalAfterDisc;
+    }
+    static GetDetailedTotalsData(finalTotalsData, IsIndependentTax, ItemsList, TaxCodes) {
+        // finalTotalsData.CustLaborDiscTotal = this.GetLaborDiscountedTotal(opCodesList);
+        finalTotalsData.CustItemsDiscTotal = this.GetItemDiscountedTotal(ItemsList);
+        // finalTotalsData.CustLaborTotalAfterDisc = this.GetLaborTotalAfterDiscount(opCodesList);
+        finalTotalsData.CustItemsTotalAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);
+        finalTotalsData.CustLaborTotalBeforeDisc = (0, aggregation_1.addition)(finalTotalsData.CustLaborTotalAfterDisc, finalTotalsData.CustLaborDiscTotal);
+        finalTotalsData.CustItemsTotalBeforeDisc = (0, aggregation_1.addition)(finalTotalsData.CustItemsTotalAfterDisc, finalTotalsData.CustItemsDiscTotal);
+        // finalTotalsData.CustLaborITax = this.GetLaborTaxTotalFor(opCodesList, IsIndependentTax);
+        // finalTotalsData.CustLaborSGST = this.GetLaborSGSTTaxTotal(opCodesList, IsIndependentTax);
+        // finalTotalsData.CustLaborCGST = this.GetLaborCGSTTaxTotal(opCodesList, IsIndependentTax);
+        // finalTotalsData.CustLaborIGST = this.GetLaborIGSTTaxTotal(opCodesList, IsIndependentTax);
+        let TaxInfo = this.GetItemGSTTaxTotal(ItemsList, IsIndependentTax);
+        finalTotalsData.CustItemITax = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[3]);
+        finalTotalsData.CustItemCGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[0]);
+        finalTotalsData.CustItemIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[2]);
+        finalTotalsData.CustItemSGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[1]);
+        // finalTotalsData.CustLaborAfterTax = TrUtils.FixedTo(finalTotalsData.CustLaborITax + finalTotalsData.CustLaborTotalAfterDisc);
+        finalTotalsData.CustItemAfterTax = (0, aggregation_1.addition)(finalTotalsData.CustItemITax, finalTotalsData.CustItemsTotalAfterDisc);
+        finalTotalsData.CustTaxGroupData = this.GetTaxGroupingForItemsByHSN(ItemsList, TaxCodes);
+        finalTotalsData.CustTotalRoundedBy = tr_utils_1.TrUtils.FixedTo(finalTotalsData.Round);
+        finalTotalsData.CustRoundedTotal = tr_utils_1.TrUtils.FixedTo(finalTotalsData.Total);
+        for (var key in finalTotalsData) {
+            if (key !== 'Total' && key !== 'SubTotal' &&
+                key !== 'LDisc' && key !== 'LPerc' && key !== 'PDisc' &&
+                key !== 'PPerc' && key !== 'Disc' && key !== 'Perc' && key !== 'Tax'
+                && typeof finalTotalsData[key] === 'number') {
+                finalTotalsData[key] = tr_utils_1.TrUtils.FixPriceValue(finalTotalsData[key]);
+            }
+        }
+        return finalTotalsData;
+    }
+    static GetLaborDiscountedTotal(LaborList) {
+        let LaborDiscountedTotal = 0;
+        LaborList.forEach((Labor) => {
+            LaborDiscountedTotal = (0, aggregation_1.addition)(LaborDiscountedTotal, Labor.DiscountedPrice);
+        });
+        return LaborDiscountedTotal;
+    }
+    static GetItemDiscountedTotal(ItemsList) {
+        let ItemsDiscountedTotal = 0;
+        ItemsList.forEach((Item) => {
+            ItemsDiscountedTotal = (0, aggregation_1.addition)(ItemsDiscountedTotal, Item.DiscountedPrice);
+        });
+        return ItemsDiscountedTotal;
+    }
+    static GetItemsTaxTotalFor(ItemsList, IsIndependentTax) {
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            ItemsList.forEach((Item) => {
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Item.CGST, Item.SGST, Item.IGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetCustomerTotalBasedOnTaxType(ItemsTaxAmount, ItemsList, IsIndependentTax) {
+        // let LaborTotalAfterDisc: any = this.GetLaborTotalAfterDiscount(LaborList);
+        let ItemsTotalAfterDisc = this.GetItemsTotalAfterDiscount(ItemsList);
+        if (IsIndependentTax) {
+            return (0, aggregation_1.addition)(ItemsTotalAfterDisc, ItemsTaxAmount);
+        }
+        else {
+            return ItemsTotalAfterDisc;
+        }
+    }
+    static LaborTotalAfterDiscount(LaborTotalAfterDisc, LaborTaxAmount, MainLDisc, LDiscInPerc) {
+        let LaborTotal = (0, aggregation_1.addition)(LaborTotalAfterDisc, LaborTaxAmount);
+        if (!tr_utils_1.TrUtils.IsZero(MainLDisc)) {
+            if (!tr_utils_1.TrUtils.IsEmpty(LDiscInPerc)) {
+                LaborTotal = (0, aggregation_1.subtraction)(LaborTotal, (0, aggregation_1.division)((0, aggregation_1.multiply)(LaborTotal, Number(LDiscInPerc)), 100));
+            }
+            else {
+                LaborTotal = (0, aggregation_1.subtraction)(LaborTotal, MainLDisc);
+            }
+        }
+        return LaborTotal;
+    }
+    static ItemsTotalAfterDiscount(ItemsTotalAfterDisc, ItemsTaxAmount, MainPDisc, PDiscInPerc) {
+        let ItemsTotal = (0, aggregation_1.addition)(ItemsTotalAfterDisc, ItemsTaxAmount);
+        if (!tr_utils_1.TrUtils.IsZero(MainPDisc)) {
+            if (!tr_utils_1.TrUtils.IsEmpty(PDiscInPerc)) {
+                ItemsTotal = (0, aggregation_1.subtraction)(ItemsTotal, (0, aggregation_1.division)((0, aggregation_1.multiply)(ItemsTotal, Number(PDiscInPerc)), 100));
+            }
+            else {
+                ItemsTotal = (0, aggregation_1.subtraction)(ItemsTotal, MainPDisc);
+            }
+        }
+        return ItemsTotal;
+    }
+    static GetLaborCGSTTaxTotal(opCodesList, IsIndependentTax) {
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            opCodesList.forEach((Labor) => {
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.CGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetLaborIGSTTaxTotal(opCodesList, IsIndependentTax) {
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            opCodesList.forEach((Labor) => {
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.IGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetLaborSGSTTaxTotal(opCodesList, IsIndependentTax) {
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            opCodesList.forEach((Labor) => {
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.SGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetItemGSTTaxTotal(ItemsList, IsIndependentTax) {
+        let TotalCGSTAmt = 0;
+        let TotalSGSTAmt = 0;
+        let TotalIGSTAmt = 0;
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            ItemsList.forEach((Item) => {
+                TotalCGSTAmt = (0, aggregation_1.addition)(TotalCGSTAmt, Item.CGST);
+                TotalSGSTAmt = (0, aggregation_1.addition)(TotalSGSTAmt, Item.SGST);
+                TotalIGSTAmt = (0, aggregation_1.addition)(TotalIGSTAmt, Item.IGST);
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Item.CGST, Item.SGST, Item.IGST);
+            });
+        }
+        return [TotalCGSTAmt, TotalSGSTAmt, TotalIGSTAmt, TotalTaxAmt];
+    }
+    static GetTaxGroupingForItemsByHSN(Items, TaxCodes) {
+        Items = this.GetCombinedTaxPercentage(Items, TaxCodes);
+        // Items = this.ResetItemsHSNIfInvalid(Items);
+        let FinalMatchedItems = this.CompareItemsByHSN(Items, TaxCodes);
+        return this.GetTaxGroupingInfoByHSN(FinalMatchedItems, TaxCodes);
+    }
+    static GetCombinedTaxPercentage(Items, TaxCodes) {
+        Items.forEach((Item) => {
+            if (tr_utils_1.TrUtils.IsNull(Item.HSN)) {
+                Item.HSN = '';
+            }
+            let TaxInfo = this.GetGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+            Item.CGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[0]);
+            Item.SGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[1]);
+            Item.IGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[2]);
+            Item.CombinedTaxPercentage = (0, aggregation_1.addition)(Item.CGSTAmt, Item.SGSTAmt, Item.IGSTAmt);
+        });
+        return Items;
+    }
+    static CompareItemsByHSN(Items, TaxCodes) {
+        let FinalMatchedItems = [];
+        Items.forEach((Item) => {
+            let MatchedItemsBasedOnHSN = Items.filter((argItem) => {
+                let ItemFound = false;
+                FinalMatchedItems.forEach((FinalArgItems) => {
+                    let ItemIndex = FinalArgItems.findIndex((FinalArgItem) => {
+                        return FinalArgItem._id === argItem._id;
+                    });
+                    if (ItemIndex !== -1) {
+                        ItemFound = true;
+                    }
+                });
+                // let argGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(argItem.TCode, TaxCodes);
+                // let argCGST = argGSTValues[0];
+                // let argSGST = argGSTValues[1];
+                // let argIGST = argGSTValues[2];
+                // let ItemGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
+                // let ItemCGST = ItemGSTValues[0];
+                // let ItemSGST = ItemGSTValues[1];
+                // let ItemIGST = ItemGSTValues[2];
+                return (argItem.HSN === Item.HSN) && (!ItemFound) &&
+                    (argItem.CGSTAmt === Item.CGSTAmt) && (argItem.IGSTAmt === Item.IGSTAmt) &&
+                    (argItem.SGSTAmt === Item.SGSTAmt);
+            });
+            if (MatchedItemsBasedOnHSN.length !== 0) {
+                FinalMatchedItems.push(MatchedItemsBasedOnHSN);
+            }
+        });
+        return FinalMatchedItems;
+    }
+    static GetTaxGroupingInfoByHSN(FinalMatchedItems, TaxCodes) {
+        let HSNTaxInfo = [];
+        FinalMatchedItems.forEach((MatchedItem) => {
+            let TaxInfo = {};
+            let TaxOnAmount = 0;
+            let TaxAmount = 0;
+            let HSN = MatchedItem[0].HSN;
+            TaxInfo.CombinedTaxPercentage = MatchedItem[0].CombinedTaxPercentage;
+            MatchedItem.forEach((argMatchedGSTItem) => {
+                TaxOnAmount = (0, aggregation_1.addition)(TaxOnAmount, argMatchedGSTItem.AfterItemDisc);
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, argMatchedGSTItem.CGST);
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, argMatchedGSTItem.IGST);
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, argMatchedGSTItem.SGST);
+            });
+            TaxInfo.HSN = HSN;
+            TaxInfo.TotalTaxableAmount = tr_utils_1.TrUtils.FixPriceValue(TaxOnAmount);
+            TaxInfo.TotalTaxAmount = tr_utils_1.TrUtils.FixPriceValue(TaxAmount);
+            TaxInfo.ItemsCount = MatchedItem.length;
+            // let GSTValues: any[] = this.GetGSTValueBasedOnTaxCode(MatchedItem[0].TCode, TaxCodes);
+            // TaxInfo.CGST = GSTValues[0];
+            // TaxInfo.SGST = GSTValues[1];
+            // TaxInfo.IGST = GSTValues[2];
+            TaxInfo.CGST = MatchedItem[0].CGSTAmt;
+            TaxInfo.IGST = MatchedItem[0].IGSTAmt;
+            TaxInfo.SGST = MatchedItem[0].SGSTAmt;
+            if (TaxOnAmount !== 0) {
+                HSNTaxInfo.push(TaxInfo);
+            }
+        });
+        return HSNTaxInfo;
+    }
+    static GetGSTValueBasedOnTaxCode(TCode, TaxCodes) {
+        let CGST = 0;
+        let SGST = 0;
+        let IGST = 0;
+        if (tr_utils_1.TrUtils.IsNull(TCode)) {
+            return [CGST, SGST, IGST];
+        }
+        let TCodeIndex = TaxCodes.findIndex((TaxCode) => {
+            return TaxCode._id === Number(TCode);
+        });
+        if (TCodeIndex !== -1) {
+            if (TaxCodes[TCodeIndex].Type === 'Intra') {
+                return [TaxCodes[TCodeIndex].CGST, TaxCodes[TCodeIndex].SGST, 0];
+            }
+            else {
+                return [0, 0, TaxCodes[TCodeIndex].IGST];
+            }
+        }
+        else {
+            return [CGST, SGST, IGST];
+        }
+    }
+}
+exports.SalesTotalsService = SalesTotalsService;

package/dist/services/scheduled-drug-pdf.service.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledDrugPDFService = 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 ScheduledDrugPDFService {
+    static GetScheduledDrugPrint(InvoicesData, CName, searchValue) {
+        var dd = {
+            info: {
+                title: 'ScheduledDrugs',
+            },
+            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: 'Schedule Wise Drug Sales', alignment: 'center', fontSize: 15, bold: true },
+                // { text: 'As of ' + MyDate.ConvertUTCDateToReadable(MyDate.GetDateTimeNowInUTC()), alignment: 'center', fontSize: 10 },
+                // SharedPDFService.HeaderAfterLine(),
+                shared_pdf_service_1.SharedPDFService.GetSearchValueDetails(searchValue),
+                this.GetInvoiceDataTable(InvoicesData),
+            ],
+            styles: shared_pdf_service_1.SharedPDFService.GetStyles()
+        };
+        return dd;
+    }
+    static GetInvoiceDataTable(InvoicesData) {
+        let Data = [];
+        // InvoicesData.forEach((invoice: any) => {
+        Data.push(this.GetItemsTable(InvoicesData));
+        // });
+        return Data;
+    }
+    static getTableWidths() {
+        // if (isHC) {
+        //     return [25, '*', '*', '*', '*'];
+        // } else {
+        return [22, 50, 50, '*', '*', '*', 40, 40, 25, 40, 40];
+        // }
+    }
+    static GetItemsTable(InvoiceData) {
+        // InvoicesData.forEach((InvoiceData: any) => {
+        return {
+            style: 'tableExample',
+            marginTop: 3,
+            marginBottom: 5,
+            table: {
+                widths: this.getTableWidths(),
+                headerRows: 1,
+                body: this.BuildTableBodyForLaborAndParts(InvoiceData)
+                // body:[['fsdfsdf','asfafdas','asdasdas','asdasdasd','asddass']]
+            },
+            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;
+                },
+                // hLineStyle: function (i, node) {
+                //     return (i === 0 || i === 1) ? { dash: { length: 5, space: 5 } } : null;
+                // },
+                hLineColor: function (i, node) {
+                    return (i === 0 || i === 1 || i === node.table.body.length) ? 'gray' : 'lightgrey';
+                },
+                vLineColor: function (i, node) {
+                    return 'gray';
+                },
+            }
+        };
+        // });
+    }
+    static BuildTableBodyForLaborAndParts(InvoiceData) {
+        let body = this.GetHeaderNames();
+        // let Row: any = [{ text: InvoiceData.Name, alignment: 'left', colSpan: isHC ? 5 : 8, bold: true, fontSize: 12 }, {}, {}, {}, {}];
+        // if (!isHC) {
+        //     Row.push({});
+        //     Row.push({});
+        //     Row.push({});
+        // }
+        // body.unshift(Row);
+        // InvoicesData.forEach((InvoiceData: any) => {
+        InvoiceData.forEach((invoice, index) => {
+            let dataRow = [];
+            // if (isHC) {
+            //     dataRow.push({ text: index + 1 });
+            //     dataRow.push({ text: invoice.Code });
+            //     if (!isHC) {
+            //         dataRow.push({ text: invoice.Prod?.RegNo });
+            //         dataRow.push({ text: TrUtils.IsNull(invoice.Prod) ? '' : invoice.Prod?.Model + ' ' + invoice.Prod?.Var });
+            //     }
+            //     // dataRow.push({ text: invoice.BFrom.Name, alignment: 'left', style: ['headerstyle'], });
+            //     dataRow.push({ text: MyDate.ConvertUTCDateToReadable(invoice.CrDate), alignment: 'center', style: ['headerstyle'], });
+            //     dataRow.push({ text: TrUtils.FixPriceValue(invoice.Total), alignment: 'right', style: ['headerstyle'], });
+            //     dataRow.push({ text: TrUtils.FixPriceValue(invoice.Due), alignment: 'right', style: ['headerstyle'], });
+            //     body.push(dataRow);
+            //     if (InvoiceData.Invoices.length === (index + 1)) {
+            //         let Row: any = [{ text: 'Total Due ', alignment: 'right', colSpan: isHC ? 4 : 6, bold: true, fontSize: 9 }, {}, {}, {}, { text: TrUtils.FixPriceValue(InvoiceData.Balance), fontSize: 9, alignment: 'right', bold: true }];
+            //         if (!isHC) {
+            //             Row.splice(2, 0, {}, {});
+            //             // Row.push({});
+            //         }
+            //         body.push(Row);
+            //     }
+            // } else {
+            dataRow.push({ text: index + 1 });
+            dataRow.push({ text: invoice.Code });
+            dataRow.push({ text: my_date_1.MyDate.ConvertUTCDateToReadable(invoice.CrDate), style: ['headerstyle'], });
+            dataRow.push({ text: invoice.CustName });
+            dataRow.push({ text: invoice.Name });
+            dataRow.push({ text: invoice.ItemName });
+            let batchdata;
+            // invoice?.Items?.Batches?.forEach((batch: any) => {
+            if (!tr_utils_1.TrUtils.IsNull(invoice.Batch)) {
+                batchdata = invoice.Batch.BN;
+            }
+            //     else {
+            //         batchdata = batch.BN;
+            //     }
+            //     //   }
+            // });
+            let batchExdate;
+            // invoice.Items?.Batches?.forEach((batch: any) => {
+            if (!tr_utils_1.TrUtils.IsNull(invoice.Batch)) {
+                batchExdate = batchExdate + ',' + my_date_1.MyDate.ConvertUTCDateToReadableExDate(invoice.Batch.ExDt);
+            }
+            //  else {
+            //     batchExdate = MyDate.ConvertUTCDateToReadableExDate(batch.ExDt);
+            // }
+            // });
+            // if(!isHC){
+            dataRow.push({ text: batchdata });
+            dataRow.push({ text: batchExdate });
+            dataRow.push({ text: tr_utils_1.TrUtils.FixPriceValue(invoice.Qty), alignment: 'right' });
+            dataRow.push({ text: tr_utils_1.TrUtils.FixPriceValue(invoice.NetAmt), alignment: 'right' });
+            dataRow.push({ text: tr_utils_1.TrUtils.FixPriceValue(invoice.Tax), alignment: 'right' });
+            // dataRow.push({ text: TrUtils.FixPriceValue(invoice.Total), alignment: 'right' });
+            // dataRow.push({ text: TrUtils.IsNull(invoice.Prod) ? '' : invoice.Prod?.Model + ' ' + invoice.Prod?.Var });
+            // }
+            // dataRow.push({ text: invoice.BFrom.Name, alignment: 'left', style: ['headerstyle'], });
+            // dataRow.push({ text: TrUtils.FixPriceValue(invoice.UnAmt + invoice.Tax), alignment: 'right', style: ['headerstyle'], });
+            // dataRow.push({ text: TrUtils.FixPriceValue(invoice.Due), alignment: 'right', style: ['headerstyle'], });
+            body.push(dataRow);
+            // if (InvoiceData.Invoices.length === (index + 1)) {
+            //     let Row: any = [{ text: 'Total Due ', alignment: 'right', colSpan: isHC?4:6, bold: true, fontSize: 9 }, {}, {}, {}, { text: TrUtils.FixPriceValue(InvoiceData.Balance), fontSize: 9, alignment: 'right', bold: true }];
+            //     if(!isHC){
+            //         Row.splice(2, 0,{},{});
+            //         // Row.push({});
+            //     }
+            //     body.push(Row);
+            // }
+            // }
+        });
+        // });
+        return body;
+    }
+    static GetHeaderNames() {
+        let HeadingNames;
+        HeadingNames = [[{ text: 'S.No', style: 'tableheader1', Field: 'SNo', alignment: 'left', line: true },
+                { text: 'Transaction #', style: 'tableheader1', Field: 'Code' },
+                { text: 'Created Date', style: 'tableheader1', Field: 'CrDate' },
+                { text: 'Customer Name', style: 'tableheader1', Field: 'CustName' },
+                { text: 'Doctor Name', style: 'tableheader1', Field: 'Name', },
+                { text: 'Item Name', style: 'tableheader1', Field: 'Desc' },
+                { text: 'Batch No', style: 'tableheader1', Field: 'Batch' },
+                { text: 'Expiry', style: 'tableheader1', Field: 'Expiry' },
+                { text: 'Qty', style: 'tableheader1', Field: 'Round', alignment: 'right' },
+                { text: 'Amount', style: 'tableheader1', Field: 'Total', alignment: 'right' },
+                { text: 'Tax', style: 'tableheader1', Field: 'Total', alignment: 'right' }]
+        ];
+        return HeadingNames;
+    }
+}
+exports.ScheduledDrugPDFService = ScheduledDrugPDFService;