shareneus 1.0.5

package/dist/services/delivery-challan-totals.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeliveryChallanTotalsService = void 0;
+const aggregation_1 = require("../aggregation/aggregation");
+const tr_utils_1 = require("../utils/tr-utils");
+class DeliveryChallanTotalsService {
+    static GetTotalsValue(PartsList, IsIndependentTax, DetailedInfo, Disc, Perc, TaxCodes, WithItems, Settings, isRoundable) {
+        // LPerc = TrUtils.SetPercToStringIfNull(LPerc);
+        Perc = tr_utils_1.TrUtils.SetPercToStringIfNull(Perc);
+        // LDisc = TrUtils.SetValueToZeroIfNull(LDisc);
+        Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Disc);
+        PartsList = this.CalculateLaborPartValues(PartsList, IsIndependentTax);
+        let finalTotalsData = this.GetFinalChallanDataForSave(PartsList, IsIndependentTax, Disc, Perc, DetailedInfo, Settings, isRoundable);
+        if (DetailedInfo) {
+            finalTotalsData = this.GetDetailedTotalsData(finalTotalsData, IsIndependentTax, PartsList, TaxCodes);
+        }
+        if (WithItems) {
+            finalTotalsData.Items = PartsList;
+        }
+        return finalTotalsData;
+    }
+    static CalculateLaborPartValues(PartsList, IsIndependentTax) {
+        PartsList = this.ResetLaborPartValues(PartsList, IsIndependentTax);
+        // PartsList = this.GetLaborPartsDiscountPrice(PartsList);
+        // PartsList = this.GetLaborPartsAfterDiscount(PartsList);
+        // PartsList = this.GetPartsAfterTax(PartsList, IsIndependentTax);
+        return PartsList;
+    }
+    static ResetLaborPartValues(PartsList, IsIndependentTax) {
+        PartsList.forEach((Part) => {
+            Part = this.ResetLaborPartValueIfInvalid(Part);
+            Part.DiscountedPrice = (0, aggregation_1.addition)(Part.Disc, tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.RecDisc));
+            Part.AfterPartDisc = Part.NetAmt;
+            if (IsIndependentTax) {
+                Part.AfterPartTax = (0, aggregation_1.addition)(Part.AfterPartDisc, Part.CGST, Part.SGST, Part.IGST);
+            }
+            else {
+                Part.AfterPartTax = Part.AfterPartDisc;
+            }
+        });
+        return PartsList;
+    }
+    static ResetLaborPartValueIfInvalid(Part) {
+        Part.UnPr = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.UnPr);
+        Part.Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.Disc);
+        Part.RecDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.RecDisc);
+        Part.CGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.CGST);
+        Part.SGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.SGST);
+        Part.IGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.IGST);
+        return Part;
+    }
+    static GetFinalChallanDataForSave(PartsList, IsIndependentTax, Disc, Perc, DetailedInfo, Settings, isRoundable) {
+        let finalTotalsData = {};
+        finalTotalsData = this.SetMainDiscountValues(Disc, Perc, finalTotalsData, DetailedInfo);
+        finalTotalsData.Settings = Settings;
+        finalTotalsData = this.GetFinalCustomerTotalsData(finalTotalsData, PartsList, IsIndependentTax, DetailedInfo, isRoundable);
+        return finalTotalsData;
+    }
+    static SetMainDiscountValues(Disc, Perc, finalTotalsData, DetailedInfo) {
+        finalTotalsData.Disc = Disc;
+        finalTotalsData.Perc = Perc;
+        if (DetailedInfo) {
+            finalTotalsData.FixedDisc = Disc;
+        }
+        return finalTotalsData;
+    }
+    static GetFinalCustomerTotalsData(finalTotalsData, PartsList, IsIndependentTax, DetailedInfo, isRoundable) {
+        let CustomerAfterDiscTotals = this.GetSubTotalFor(PartsList);
+        // let CustLaborTaxTotal = this.GetLaborTaxTotalFor(IsIndependentTax);
+        let CustPartTaxTotal = this.GetPartsTaxTotalFor(PartsList, IsIndependentTax);
+        // console.log('CustPartTaxTotal', CustPartTaxTotal);
+        finalTotalsData.SubTotal = tr_utils_1.TrUtils.FixedTo(CustomerAfterDiscTotals);
+        let CustTotal = this.GetCustomerTotalBasedOnTaxType(CustPartTaxTotal, PartsList, IsIndependentTax);
+        // console.log('CustTotal', CustTotal);
+        if (isRoundable) {
+            finalTotalsData.Round = tr_utils_1.TrUtils.FixedTo(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(PartsList) {
+        // let LaborTotalAfterDisc: any = this.GetLaborTotalAfterDiscount(LaborList);
+        let PartsTotalAfterDisc = this.GetPartsTotalAfterDiscount(PartsList);
+        return PartsTotalAfterDisc;
+    }
+    static GetPartsTotalAfterDiscount(PartsList) {
+        let PartsTotalAfterDisc = 0;
+        // console.log('PartsList', PartsList);
+        PartsList.forEach((Part) => {
+            PartsTotalAfterDisc = (0, aggregation_1.addition)(PartsTotalAfterDisc, Part.AfterPartDisc);
+        });
+        return PartsTotalAfterDisc;
+    }
+    static GetDetailedTotalsData(finalTotalsData, IsIndependentTax, PartsList, TaxCodes) {
+        // finalTotalsData.CustLaborDiscTotal = this.GetLaborDiscountedTotal(opCodesList);
+        finalTotalsData.CustPartsDiscTotal = this.GetPartDiscountedTotal(PartsList);
+        // finalTotalsData.CustLaborTotalAfterDisc = this.GetLaborTotalAfterDiscount(opCodesList);
+        finalTotalsData.CustPartsTotalAfterDisc = this.GetPartsTotalAfterDiscount(PartsList);
+        finalTotalsData.CustLaborTotalBeforeDisc = (0, aggregation_1.addition)(finalTotalsData.CustLaborTotalAfterDisc, finalTotalsData.CustLaborDiscTotal);
+        finalTotalsData.CustPartsTotalBeforeDisc = (0, aggregation_1.addition)(finalTotalsData.CustPartsTotalAfterDisc, finalTotalsData.CustPartsDiscTotal);
+        // finalTotalsData.CustLaborITax = this.GetLaborTaxTotalFor(opCodesList, IsIndependentTax);
+        // finalTotalsData.CustLaborSGST = this.GetLaborSGSTTaxTotal(opCodesList, IsIndependentTax);
+        // finalTotalsData.CustLaborCGST = this.GetLaborCGSTTaxTotal(opCodesList, IsIndependentTax);
+        // finalTotalsData.CustLaborIGST = this.GetLaborIGSTTaxTotal(opCodesList, IsIndependentTax);
+        // finalTotalsData.CustPartITax = this.GetPartsTaxTotalFor(PartsList, IsIndependentTax);
+        // finalTotalsData.CustPartCGST = this.GetPartCGSTTaxTotal(PartsList, IsIndependentTax);
+        // finalTotalsData.CustPartIGST = this.GetPartIGSTTaxTotal(PartsList, IsIndependentTax);
+        // finalTotalsData.CustPartSGST = this.GetPartSGSTTaxTotal(PartsList, IsIndependentTax);
+        let TaxInfo = this.GetPartGSTTaxTotal(PartsList, IsIndependentTax);
+        finalTotalsData.CustPartITax = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[3]);
+        finalTotalsData.CustPartCGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[0]);
+        finalTotalsData.CustPartIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[2]);
+        finalTotalsData.CustPartSGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[1]);
+        // finalTotalsData.CustLaborAfterTax = TrUtils.FixedTo(finalTotalsData.CustLaborITax + finalTotalsData.CustLaborTotalAfterDisc);
+        finalTotalsData.CustPartAfterTax = (0, aggregation_1.addition)(finalTotalsData.CustPartITax, finalTotalsData.CustPartsTotalAfterDisc);
+        finalTotalsData.CustTaxGroupData = this.GetTaxGroupingForPartsByHSN(PartsList, 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 GetPartDiscountedTotal(PartsList) {
+        let PartsDiscountedTotal = 0;
+        PartsList.forEach((Part) => {
+            PartsDiscountedTotal = (0, aggregation_1.addition)(PartsDiscountedTotal, Part.DiscountedPrice);
+        });
+        return PartsDiscountedTotal;
+    }
+    static GetPartsTaxTotalFor(PartsList, IsIndependentTax) {
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            PartsList.forEach((Part) => {
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CGST, Part.SGST, Part.IGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetCustomerTotalBasedOnTaxType(PartsTaxAmount, PartsList, IsIndependentTax) {
+        // let LaborTotalAfterDisc: any = this.GetLaborTotalAfterDiscount(LaborList);
+        let PartsTotalAfterDisc = this.GetPartsTotalAfterDiscount(PartsList);
+        if (IsIndependentTax) {
+            return (0, aggregation_1.addition)(PartsTotalAfterDisc, PartsTaxAmount);
+        }
+        else {
+            return PartsTotalAfterDisc;
+        }
+    }
+    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(PartsTotalAfterDisc, PartsTaxAmount, MainPDisc, PDiscInPerc) {
+        let ItemsTotal = (0, aggregation_1.addition)(PartsTotalAfterDisc, PartsTaxAmount);
+        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 GetPartGSTTaxTotal(PartsList, IsIndependentTax) {
+        let TotalCGSTAmt = 0;
+        let TotalSGSTAmt = 0;
+        let TotalIGSTAmt = 0;
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            PartsList.forEach((Part) => {
+                TotalCGSTAmt = (0, aggregation_1.addition)(TotalCGSTAmt, Part.CGST);
+                TotalSGSTAmt = (0, aggregation_1.addition)(TotalSGSTAmt, Part.SGST);
+                TotalIGSTAmt = (0, aggregation_1.addition)(TotalIGSTAmt, Part.IGST);
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CGST, Part.SGST, Part.IGST);
+            });
+        }
+        return [TotalCGSTAmt, TotalSGSTAmt, TotalIGSTAmt, TotalTaxAmt];
+    }
+    static GetTaxGroupingForPartsByHSN(Parts, TaxCodes) {
+        Parts = this.GetCombinedTaxPercentage(Parts, TaxCodes);
+        // Parts = this.ResetPartsHSNIfInvalid(Parts);
+        let FinalMatchedParts = this.ComparePartsByHSN(Parts, TaxCodes);
+        return this.GetTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes);
+    }
+    static GetCombinedTaxPercentage(Parts, TaxCodes) {
+        Parts.forEach((Part) => {
+            if (tr_utils_1.TrUtils.IsNull(Part.HSN)) {
+                Part.HSN = '';
+            }
+            let GSTValues = this.GetGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+            Part.CGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(GSTValues[0]);
+            Part.SGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(GSTValues[1]);
+            Part.IGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(GSTValues[2]);
+            Part.CombinedTaxPercentage = (0, aggregation_1.addition)(Part.CGSTAmt, Part.SGSTAmt, Part.IGSTAmt);
+        });
+        return Parts;
+    }
+    static ComparePartsByHSN(Parts, TaxCodes) {
+        let FinalMatchedParts = [];
+        Parts.forEach((Part) => {
+            let MatchedPartsBasedOnHSN = Parts.filter((argPart) => {
+                let PartFound = false;
+                FinalMatchedParts.forEach((FinalArgParts) => {
+                    let PartIndex = FinalArgParts.findIndex((FinalArgPart) => {
+                        return FinalArgPart._id === argPart._id;
+                    });
+                    if (PartIndex !== -1) {
+                        PartFound = true;
+                    }
+                });
+                // let argGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(argPart.TCode, TaxCodes);
+                // let argCGST = argGSTValues[0];
+                // let argSGST = argGSTValues[1];
+                // let argIGST = argGSTValues[2];
+                // let partGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+                // let partCGST = partGSTValues[0];
+                // let partSGST = partGSTValues[1];
+                // let partIGST = partGSTValues[2];
+                return (argPart.HSN === Part.HSN) && (!PartFound) &&
+                    (argPart.CGSTAmt === Part.CGSTAmt) && (argPart.IGSTAmt === Part.IGSTAmt) &&
+                    (argPart.SGSTAmt === Part.SGSTAmt);
+            });
+            if (MatchedPartsBasedOnHSN.length !== 0) {
+                FinalMatchedParts.push(MatchedPartsBasedOnHSN);
+            }
+        });
+        return FinalMatchedParts;
+    }
+    static GetTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes) {
+        let HSNTaxInfo = [];
+        FinalMatchedParts.forEach((MatchedPart) => {
+            let TaxInfo = {};
+            let TaxOnAmount = 0;
+            let TaxAmount = 0;
+            let HSN = MatchedPart[0].HSN;
+            TaxInfo.CombinedTaxPercentage = MatchedPart[0].CombinedTaxPercentage;
+            MatchedPart.forEach((argMatchedGSTPart) => {
+                TaxOnAmount = (0, aggregation_1.addition)(TaxOnAmount, argMatchedGSTPart.AfterPartDisc);
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, argMatchedGSTPart.CGST);
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, argMatchedGSTPart.IGST);
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, argMatchedGSTPart.SGST);
+            });
+            TaxInfo.HSN = HSN;
+            TaxInfo.TotalTaxableAmount = tr_utils_1.TrUtils.FixPriceValue(TaxOnAmount);
+            TaxInfo.TotalTaxAmount = tr_utils_1.TrUtils.FixPriceValue(TaxAmount);
+            TaxInfo.ItemsCount = MatchedPart.length;
+            // let GSTValues: any[] = this.GetGSTValueBasedOnTaxCode(MatchedPart[0].TCode, TaxCodes);
+            // TaxInfo.CGST = GSTValues[0];
+            // TaxInfo.SGST = GSTValues[1];
+            // TaxInfo.IGST = GSTValues[2];
+            TaxInfo.CGST = MatchedPart[0].CGSTAmt;
+            TaxInfo.IGST = MatchedPart[0].IGSTAmt;
+            TaxInfo.SGST = MatchedPart[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.DeliveryChallanTotalsService = DeliveryChallanTotalsService;

package/dist/services/equipment-design-pdf.service.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EquipmentDesignPdf = void 0;
+const shared_print_service_1 = require("./shared-print.service");
+const shared_pdf_service_1 = require("./shared-pdf.service");
+const tr_utils_1 = require("../utils/tr-utils");
+class EquipmentDesignPdf {
+    static GetEquipmentPdf(Entity, Image, Sites, Items) {
+        var dd = {
+            info: {
+                title: 'Equipment Design',
+            },
+            background: function (currentPage, pageSize) {
+                return shared_pdf_service_1.SharedPDFService.GetWatermarkImage(Image, pageSize, Entity.Wmark);
+            },
+            header: function (currentPage, pageCount) {
+                return { text: currentPage.toString() + ' of ' + pageCount, alignment: 'right', marginRight: 7, fontSize: 8, marginTop: 2 };
+            },
+            pageMargins: [10, 15, 10, 15],
+            content: this.GetContentData(Entity, Sites, Items, Image),
+            // styles: SharedPDFService.GetStyles()
+        };
+        return dd;
+    }
+    static GetContentData(Entity, Sites, Items, Image) {
+        let EntityData = shared_print_service_1.PrintSharedService.GetFormattedEntityDataForPrint(tr_utils_1.TrUtils.Stringify(Entity), '', null);
+        Entity = shared_print_service_1.PrintSharedService.GetEntityHeaderStyles(Entity, Entity, Image);
+        EntityData.HColor = Entity.HColor;
+        return [
+            // SharedPDFService.MainHeading(EntityData.CName, EntityData.Header, Image, EntityData.HColor, null),
+            { text: EntityData.CName, fontSize: 26, bold: true, color: EntityData.HColor, alignment: 'center' },
+            { text: 'EQUIPMENT DESIGN', bold: true, alignment: 'center', marginBottom: 20, marginTop: 20, decoration: 'underline' },
+            {
+                style: 'tableExample',
+                color: '#444',
+                table: {
+                    widths: ['auto', '*', '*', '*', '*'],
+                    headerRows: 1,
+                    body: this.getsites(Sites, Items)
+                },
+                layout: shared_print_service_1.PrintSharedService.LayOutStyle()
+            },
+        ];
+    }
+    static getsites(Sites, Items) {
+        let mainsites = [];
+        mainsites = Sites.filter((site) => {
+            return tr_utils_1.TrUtils.IsNull(site.Parent);
+        });
+        mainsites.forEach((site, pindex) => {
+            site.Index = pindex + 1;
+            site.children = this.GetChildren(Sites, site.Id, site.Index);
+        });
+        var body = [[{ text: 'SNO', bold: true }, { text: 'Location', bold: true }, { text: 'Quantity', bold: true }, { text: 'Tonnage(TR)', bold: true }, { text: 'Model', bold: true }]];
+        var SNO = 0;
+        mainsites.forEach((item) => {
+            var lo = [];
+            // lo.push({ text: item.Name, colSpan: item.children.length });
+            // lo.push({});
+            let Itemdata = this.GetItem(item.ItemId, Items);
+            if (tr_utils_1.TrUtils.IsNull(Itemdata.TR)) {
+                Itemdata.TR = '';
+            }
+            if (tr_utils_1.TrUtils.IsNull(Itemdata.Model)) {
+                Itemdata.Model = '';
+            }
+            if (tr_utils_1.TrUtils.IsNull(item.Qty)) {
+                item.Qty = '';
+            }
+            if (tr_utils_1.TrUtils.IsNull(item.children) || item.children.length === 0) {
+                lo.push({ text: item.Index });
+                lo.push({ text: item.Name });
+                lo.push({ text: item.Qty });
+                lo.push({ text: Itemdata.TR });
+                lo.push({ text: Itemdata.Model });
+            }
+            else {
+                lo.push({ text: item.Index });
+                lo.push({ text: item.Name, colSpan: 4 });
+                lo.push({});
+                lo.push({});
+                lo.push({});
+            }
+            body.push(lo);
+            body = this.tablechilderan(Sites, item.Id, body, Items);
+        });
+        return body;
+    }
+    static GetChildren(Sites, siteid, pindex) {
+        let children = Sites.filter((site) => {
+            return site.Parent === siteid;
+        });
+        children.forEach((child, cindex) => {
+            child.Index = pindex + '.' + (cindex + 1);
+            child.children = this.GetChildren(Sites, child.Id, child.Index);
+        });
+        return children;
+    }
+    static tablechilderan(Sites, siteid, body, Items) {
+        let children = Sites.filter((site) => {
+            return site.Parent === siteid;
+        });
+        children.forEach((child, cindex) => {
+            var sm = [];
+            // sm.push({ text: child.Name, colSpan: child.children.length })
+            // sm.push({ text: 'High wall' });
+            let Itemdata = this.GetItem(child.ItemId, Items);
+            if (tr_utils_1.TrUtils.IsNull(Itemdata.TR)) {
+                Itemdata.TR = '';
+            }
+            if (tr_utils_1.TrUtils.IsNull(Itemdata.Model)) {
+                Itemdata.Model = '';
+            }
+            if (tr_utils_1.TrUtils.IsNull(child.Qty)) {
+                child.Qty = '';
+            }
+            if (child.children.length === 0) {
+                sm.push({ text: child.Index });
+                sm.push({ text: child.Name });
+                sm.push({ text: child.Qty });
+                sm.push({ text: Itemdata.TR });
+                sm.push({ text: Itemdata.Model });
+            }
+            else {
+                // sm.splice(1, 0, { text: child.Name, colSpan: 4 });
+                sm.push({ text: child.Index });
+                sm.push({ text: child.Name, colSpan: 4 });
+                sm.push({});
+                sm.push({});
+                sm.push({});
+            }
+            body.push(sm);
+            this.tablechilderan(Sites, child.Id, body, Items);
+        });
+        return body;
+    }
+    static GetItem(ItemId, Items) {
+        let Index = Items.findIndex((item) => {
+            return item._id === ItemId;
+        });
+        return (Index !== -1) ? Items[Index] : {};
+    }
+}
+exports.EquipmentDesignPdf = EquipmentDesignPdf;