shareneus 1.0.5

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalysisPDFService = 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 AnalysisPDFService {
+    static GetAnalysisPDFPrint(InvoicesData, CName, isPhar, isHC, IsSales, HeaerName, searchValue, HeaderText) {
+        var dd = {
+            info: {
+                title: 'Analysis',
+            },
+            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: HeaerName, alignment: 'center', fontSize: 15, bold: true },
+                shared_pdf_service_1.SharedPDFService.GetSearchValueDetails(searchValue),
+                this.GetInvoiceDataTable(InvoicesData, isPhar, isHC, IsSales, HeaderText),
+            ],
+            styles: shared_pdf_service_1.SharedPDFService.GetStyles()
+        };
+        return dd;
+    }
+    static GetInvoiceDataTable(InvoicesData, isPhar, isHC, IsSales, HeaderText) {
+        let Data = [];
+        Data.push(this.GetItemsTable(InvoicesData, isPhar, isHC, IsSales, HeaderText));
+        return Data;
+    }
+    static getTableWidths(isHC) {
+        // if (isHC) {
+        return [25, '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'];
+        // } else {
+        // return [25, '*', 40, 40,  80];
+        // }
+    }
+    static GetItemsTable(InvoiceData, isPhar, isHC, IsSales, HeaderText) {
+        return {
+            style: 'tableExample',
+            marginTop: 3,
+            marginBottom: 5,
+            table: {
+                widths: this.getTableWidths(isHC),
+                headerRows: 1,
+                body: this.BuildTableBodyForLaborAndParts(InvoiceData, isPhar, isHC, IsSales, HeaderText)
+            },
+            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(InvoiceData, isPhar, isHC, IsSales, HeaderText) {
+        let body = this.GetHeaderNames(isPhar, isHC, HeaderText);
+        InvoiceData.forEach((invoice, index) => {
+            let dataRow = [];
+            dataRow.push({ text: index + 1 });
+            if (HeaderText === 'Month') {
+                dataRow.push({ text: my_date_1.MyDate.GetMonthName(invoice._id), style: ['headerstyle'], });
+            }
+            else {
+                dataRow.push({ text: my_date_1.MyDate.ConvertUTCDateToReadable(invoice._id), style: ['headerstyle'], });
+            }
+            dataRow.push({ text: invoice.Count, alignment: 'right' });
+            dataRow.push({ text: invoice.Qty, alignment: 'right' });
+            dataRow.push({ text: invoice.OfQty, alignment: 'right' });
+            dataRow.push({ text: tr_utils_1.TrUtils.FixPriceValue(invoice.SubTotal), alignment: 'right' });
+            dataRow.push({ text: tr_utils_1.TrUtils.FixPriceValue(invoice.Disc), alignment: 'right' });
+            dataRow.push({ text: tr_utils_1.TrUtils.FixPriceValue(invoice.Tax), alignment: 'right' });
+            dataRow.push({ text: tr_utils_1.TrUtils.FixPriceValue(invoice.Adjust), alignment: 'right' });
+            dataRow.push({ text: tr_utils_1.TrUtils.FixPriceValue(invoice.Round), alignment: 'right' });
+            dataRow.push({ text: tr_utils_1.TrUtils.FixPriceValue(invoice.Total), alignment: 'right', style: ['headerstyle'], });
+            body.push(dataRow);
+        });
+        return body;
+    }
+    static GetHeaderNames(isPhar, isHC, HeaderText) {
+        let HeadingNames;
+        HeadingNames = [[{ text: 'S.No', style: 'tableheader1', Field: 'SNo', alignment: 'left', line: true },
+                { text: HeaderText, style: 'tableheader1', Field: 'Name' },
+                { text: 'Count', style: 'tableheader1', Field: 'Count', alignment: 'right' },
+                { text: 'Qty', style: 'tableheader1', Field: 'Qty', alignment: 'right' },
+                { text: 'Offer Qty', style: 'tableheader1', Field: 'OfQty', alignment: 'right' },
+                { text: 'SubTotal', style: 'tableheader1', Field: 'SubTotal', alignment: 'right' },
+                { text: 'Discount', style: 'tableheader1', Field: 'Disc', alignment: 'right' },
+                { text: 'Tax', style: 'tableheader1', Field: 'Tax', alignment: 'right' },
+                { text: 'Adjustment', style: 'tableheader1', Field: 'Adjust', alignment: 'right' },
+                { text: 'Round off', style: 'tableheader1', Field: 'Round', alignment: 'right' },
+                { text: 'Total', style: 'tableheader1', Field: 'Total', alignment: 'right' }]];
+        return HeadingNames;
+    }
+}
+exports.AnalysisPDFService = AnalysisPDFService;

package/dist/services/appointment-total.service.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentTotalsService = void 0;
+const enums_1 = require("../enums/enums");
+const tr_utils_1 = require("../utils/tr-utils");
+class AppointmentTotalsService {
+    static GetTotalsValue(OriRecordData, TaxCodes, detailedInfo, withItems) {
+        let dupRecordData = tr_utils_1.TrUtils.Stringify(OriRecordData);
+        let argRecordData = {};
+        dupRecordData.Ops = this.CalculateLaborValues(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        argRecordData = this.GetROTotalsData(argRecordData, dupRecordData, TaxCodes, withItems, detailedInfo);
+        return argRecordData;
+    }
+    static CalculateLaborValues(opCodesList, isTaxable) {
+        opCodesList = this.FilterValidLaborItems(opCodesList);
+        opCodesList = this.ResetLaborValuesIfInvalid(opCodesList);
+        opCodesList = this.GetOperationsDiscountPrice(opCodesList);
+        opCodesList = this.GetOperationsAfterDiscount(opCodesList);
+        opCodesList = this.GetOperationsAfterTax(opCodesList, isTaxable);
+        return opCodesList;
+    }
+    static FilterValidLaborItems(opCodesList) {
+        opCodesList = opCodesList.filter((Labor) => {
+            return Labor.Sts !== enums_1.LaborStatusEnum.Cancelled && Labor.Sts !== enums_1.LaborStatusEnum.Declined;
+        });
+        return opCodesList;
+    }
+    static ResetLaborValuesIfInvalid(opCodesList) {
+        opCodesList.forEach((Operation) => {
+            Operation = this.ResetLaborValueIfInvalid(Operation);
+        });
+        return opCodesList;
+    }
+    static ResetLaborValueIfInvalid(Operation) {
+        Operation.Perc = tr_utils_1.TrUtils.SetPercToStringIfNull(Operation.Perc);
+        Operation.Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.Disc);
+        Operation.Pr = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.Pr);
+        Operation.CCGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.CCGST);
+        Operation.CSGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.CSGST);
+        Operation.CIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.CIGST);
+        Operation.NetAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.NetAmt);
+        Operation.RecDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Operation.RecDisc);
+        return Operation;
+    }
+    static GetOperationsDiscountPrice(OperationsList) {
+        OperationsList.forEach((Operation) => {
+            Operation.CustDiscountedPrice = Operation.Disc + Operation.RecDisc;
+        });
+        return OperationsList;
+    }
+    static GetOperationsAfterDiscount(OperationsList) {
+        OperationsList.forEach((Operation) => {
+            let CustAfterLaborDisc = 0;
+            if (Operation.PBy === enums_1.PayTypeEnum.Customer) {
+                CustAfterLaborDisc = Operation.NetAmt;
+            }
+            else {
+                CustAfterLaborDisc = Operation.NetAmt;
+            }
+            Operation.CustAfterLaborDisc = CustAfterLaborDisc;
+        });
+        return OperationsList;
+    }
+    static GetOperationsAfterTax(OperationsList, isTaxable) {
+        OperationsList.forEach((Operation) => {
+            if (!isTaxable) {
+                Operation.CustAfterTax = Operation.CustAfterLaborDisc;
+            }
+            else {
+                if (Operation.PBy === enums_1.PayTypeEnum.Customer) {
+                    Operation.CustAfterTax = Operation.CustAfterLaborDisc + Operation.CCGST + Operation.CSGST + Operation.CIGST;
+                }
+                else {
+                    Operation.CustAfterTax = Operation.CustAfterLaborDisc + Operation.CCGST + Operation.CSGST + Operation.CIGST;
+                }
+            }
+        });
+        return OperationsList;
+    }
+    static GetROTotalsData(argRecordData, dupRecordData, TaxCodes, withItems, detailedInfo) {
+        dupRecordData = this.ResetDiscountValuesIfInvalid(dupRecordData);
+        argRecordData = this.SetMainDiscountValues(argRecordData, dupRecordData, detailedInfo);
+        argRecordData = this.GetFinalCustomerTotalsData(argRecordData, dupRecordData, detailedInfo);
+        if (detailedInfo) {
+            argRecordData = this.GetDetailedTotalsData(argRecordData, dupRecordData, TaxCodes);
+        }
+        if (withItems) {
+            argRecordData.Ops = dupRecordData.Ops;
+        }
+        return argRecordData;
+    }
+    static ResetDiscountValuesIfInvalid(dupRecordData) {
+        dupRecordData.LPerc = tr_utils_1.TrUtils.SetPercToStringIfNull(dupRecordData.LPerc);
+        dupRecordData.Perc = tr_utils_1.TrUtils.SetPercToStringIfNull(dupRecordData.Perc);
+        dupRecordData.LDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(dupRecordData.LDisc);
+        dupRecordData.Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(dupRecordData.Disc);
+        return dupRecordData;
+    }
+    static SetMainDiscountValues(argRecordData, dupRecordData, detailedInfo) {
+        argRecordData.LDisc = dupRecordData.LDisc;
+        argRecordData.LPerc = dupRecordData.LPerc;
+        argRecordData.PDisc = dupRecordData.PDisc;
+        argRecordData.PPerc = dupRecordData.PPerc;
+        argRecordData.Disc = dupRecordData.Disc;
+        argRecordData.Perc = dupRecordData.Perc;
+        if (detailedInfo) {
+            argRecordData.FixedLDisc = dupRecordData.LDisc;
+            argRecordData.FixedDisc = dupRecordData.Disc;
+        }
+        return argRecordData;
+    }
+    static GetFinalCustomerTotalsData(argRecordData, dupRecordData, detailedInfo) {
+        let CustomerAfterDiscTotals = this.GetCustSubTotal(dupRecordData.Ops);
+        let CustLaborTaxTotal = this.GetCustLaborTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        let CustLaborDiscTotal = this.GetCustLaborDiscountedTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);
+        let CustLaborTotalAfterDisc = this.GetCustLaborTotalAfterDiscount(dupRecordData.Ops);
+        argRecordData.STotal = tr_utils_1.TrUtils.FixPriceValue(CustLaborDiscTotal + CustLaborTotalAfterDisc);
+        argRecordData.CustLaborTotalBeforeDisc = tr_utils_1.TrUtils.FixedTo(argRecordData.CustLaborTotalAfterDisc
+            + argRecordData.CustLaborDiscTotal);
+        argRecordData.SubTotal = tr_utils_1.TrUtils.FixedTo(CustomerAfterDiscTotals);
+        let CustTotal = this.GetCustomerTotalBasedOnTaxType(dupRecordData, CustLaborTaxTotal, dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        if (detailedInfo) {
+            argRecordData.FixedSubTotal = tr_utils_1.TrUtils.FixedTo(CustomerAfterDiscTotals);
+            argRecordData.FixedTotal = tr_utils_1.TrUtils.FixedTo(CustTotal);
+        }
+        argRecordData.Round = tr_utils_1.TrUtils.FixedTo(Math.round(CustTotal) - CustTotal);
+        argRecordData.Total = Math.round(CustTotal);
+        return argRecordData;
+    }
+    static GetCustSubTotal(LaborList) {
+        let LaborTotalAfterDisc = this.GetCustLaborTotalAfterDiscount(LaborList);
+        return LaborTotalAfterDisc;
+    }
+    static GetCustLaborTotalAfterDiscount(LaborList) {
+        let LaborTotalAfterDisc = 0;
+        LaborList.forEach((Labor) => {
+            LaborTotalAfterDisc += Labor.CustAfterLaborDisc;
+        });
+        return LaborTotalAfterDisc;
+    }
+    static GetCustLaborTaxTotal(opCodesList, IsTaxable) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor) => {
+                TotalTaxAmt = TotalTaxAmt + Labor.CCGST + Labor.CSGST + Labor.CIGST;
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetCustomerTotalBasedOnTaxType(dupRecordData, LaborTaxAmount, LaborList, IsTaxable) {
+        let SubTotalWithTax = 0;
+        let LaborTotalAfterDisc = this.GetCustLaborTotalAfterDiscount(LaborList);
+        if (IsTaxable) {
+            SubTotalWithTax = LaborTotalAfterDisc + LaborTaxAmount;
+        }
+        else {
+            SubTotalWithTax = tr_utils_1.TrUtils.FixedTo((LaborTotalAfterDisc - dupRecordData.LDisc) - dupRecordData.Disc);
+        }
+        return SubTotalWithTax;
+    }
+    static GetDetailedTotalsData(argRecordData, dupRecordData, TaxCodes) {
+        argRecordData.CustLaborDiscTotal = this.GetCustLaborDiscountedTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);
+        argRecordData.CustLaborTotalAfterDisc = this.GetCustLaborTotalAfterDiscount(dupRecordData.Ops);
+        argRecordData.CustLaborTotalBeforeDisc = tr_utils_1.TrUtils.FixedTo(argRecordData.CustLaborTotalAfterDisc
+            + argRecordData.CustLaborDiscTotal);
+        argRecordData.CustLaborITax = this.GetCustLaborTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        argRecordData.CustLaborSGST = this.GetCustLaborSGSTTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        argRecordData.CustLaborCGST = this.GetCustLaborCGSTTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        argRecordData.CustLaborIGST = this.GetCustLaborIGSTTaxTotal(dupRecordData.Ops, tr_utils_1.TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        argRecordData.CustLaborLDiscAmount = this.GetLaborLDiscAmount(argRecordData.CustLaborTotalAfterDisc, argRecordData.LDisc);
+        argRecordData.CustLaborAfterLDisc = argRecordData.CustLaborTotalAfterDisc;
+        argRecordData.CustLaborAfterTax = tr_utils_1.TrUtils.FixedTo(argRecordData.CustLaborITax + argRecordData.CustLaborAfterLDisc);
+        argRecordData.CustTotalRoundedBy = argRecordData.Round;
+        argRecordData.CustRoundedTotal = argRecordData.Total;
+        for (var key in argRecordData) {
+            if (key !== 'Total' && key !== 'SubTotal' &&
+                key !== 'LDisc' && key !== 'LPerc' && key !== 'PDisc' &&
+                key !== 'PPerc' && key !== 'Disc' && key !== 'Perc' && key !== 'Tax'
+                && typeof argRecordData[key] === 'number') {
+                argRecordData[key] = tr_utils_1.TrUtils.FixPriceValue(argRecordData[key]);
+            }
+        }
+        return argRecordData;
+    }
+    static GetCustLaborDiscountedTotal(LaborList, isTaxable, finalTotalsData) {
+        let LaborDiscountedTotal = 0;
+        let overallLaborDisc = 0;
+        if (!isTaxable) {
+            overallLaborDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(finalTotalsData.LDisc);
+        }
+        LaborList.forEach((Labor) => {
+            LaborDiscountedTotal += Labor.CustDiscountedPrice;
+        });
+        return tr_utils_1.TrUtils.FixedTo(LaborDiscountedTotal + overallLaborDisc);
+    }
+    static GetCustLaborCGSTTaxTotal(opCodesList, IsTaxable) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor) => {
+                TotalTaxAmt = TotalTaxAmt + Labor.CCGST;
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetCustLaborIGSTTaxTotal(opCodesList, IsTaxable) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor) => {
+                TotalTaxAmt = TotalTaxAmt + Labor.CIGST;
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetCustLaborSGSTTaxTotal(opCodesList, IsTaxable) {
+        let TotalTaxAmt = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor) => {
+                TotalTaxAmt = TotalTaxAmt + Labor.CSGST;
+            });
+        }
+        return TotalTaxAmt;
+    }
+    static GetLaborLDiscAmount(LaborTotalAfterDisc, LDisc) {
+        let LaborLDiscAmt = 0;
+        if (!tr_utils_1.TrUtils.IsZero(LaborTotalAfterDisc)) {
+            LaborLDiscAmt = LDisc;
+        }
+        return LaborLDiscAmt;
+    }
+    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.AppointmentTotalsService = AppointmentTotalsService;