shareneus 1.7.4 → 1.7.6

package/src/accounting/payment-receive/reports/pdf/payment-report-pdf.service.ts

@@ -0,0 +1,116 @@
+
+import { SharedPDFService } from '../../../../shared/shared-pdf.service';
+import { MyDate } from '../../../../utils/my-date';
+import { TrUtils } from '../../../../utils/tr-utils';
+declare var pdfMake: any;
+
+export class PaymentsReportPDFService {
+
+    static GetPaymentsReportPrint(InvoicesData: any, EntityData: any, HeaerName:any, ispur:boolean,isSale:boolean, searchValue:any) {
+        var dd = {
+            info: {
+                title: 'PaymentReport',
+            },
+            header: function (currentPage: any, pageCount: any) {
+                return { text: currentPage.toString() + ' of ' + pageCount, alignment: 'right', marginRight: 7, fontSize: 8, marginTop: 2 };
+            },
+            pageMargins: [10, 15, 10, 15],
+            content: [
+                { text: '' + EntityData.Entity.DName + '', style: ['header'] },
+                { text: HeaerName, alignment: 'center', fontSize: 15, bold: true },
+                SharedPDFService.GetSearchValueDetails(searchValue),
+                this.GetInvoiceDataTable(InvoicesData, ispur, isSale, EntityData.User.TZ, EntityData.Entity.Settings.DecimalsNumber),
+
+            ],
+            styles: SharedPDFService.GetStyles()
+        };
+        return dd;
+
+    }
+
+    static GetInvoiceDataTable(InvoicesData: any, ispur:boolean, isSale:boolean, UserTimeZone: any, DecimalsNumber: number) {
+        let Data: any = []
+        // InvoicesData.forEach((invoice: any) => {
+            Data.push(this.GetItemsTable(InvoicesData, ispur, isSale, UserTimeZone, DecimalsNumber));
+        // });
+
+        return Data;
+    }
+
+    static getTableWidths() {
+        // if (isHC) {
+            return [22,  50, '*', 90,80, 70];
+        // } else {
+            // return [25, '*', 40, 40,  80];
+        // }
+    }
+
+    static GetItemsTable(InvoiceData: any, ispur:boolean, isSale:boolean, UserTimeZone: any, DecimalsNumber: number) {
+        // InvoicesData.forEach((InvoiceData: any) => {
+        return {
+            style: 'tableExample',
+            marginTop: 3,
+            marginBottom: 5,
+            table: {
+                widths: this.getTableWidths(),
+                headerRows: 1,
+                body: this.BuildTableBodyForLaborAndParts(InvoiceData, ispur, isSale, UserTimeZone, DecimalsNumber)
+                // body:[['fsdfsdf','asfafdas','asdasdas','asdasdasd','asddass']]
+            },
+            layout: {
+                hLineWidth: function (i:any, node:any) {
+
+                    return (i === 0 || i === 1 || i === node.table.body.length) ? 1 : 0.5;
+                },
+                vLineWidth: function (i:any, node:any) {
+                    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: any, node: any) {
+                    return (i === 0 || i === 1 || i === node.table.body.length) ? 'gray' : 'lightgrey';
+
+                },
+                vLineColor: function (i: any, node: any) {
+                    return 'gray';
+                },
+            }
+        };
+        // });
+    }
+
+    static BuildTableBodyForLaborAndParts(InvoiceData: any, ispur:boolean, isSale:boolean, UserTimeZone: any, DecimalsNumber: number) {
+        let body: any = this.GetHeaderNames(ispur);
+        InvoiceData.forEach((invoice: any, index: any) => {
+            let dataRow: any = [];
+                dataRow.push({ text: index + 1 });
+                    dataRow.push({ text:invoice.Code,  style: ['headerstyle'], });
+                dataRow.push({ text: isSale?invoice.CustName:invoice.Name });
+
+                dataRow.push({ text:isSale? MyDate.ConvertUTCDateTimeToReadable(invoice.Pay.Dt, UserTimeZone):MyDate.ConvertUTCDateTimeToReadable(invoice.Date, UserTimeZone) });
+                dataRow.push({ text: isSale?invoice.Pay.Type:invoice.PType });
+                dataRow.push({ text: isSale?TrUtils.FixPriceValue(invoice.Pay?.Amt, DecimalsNumber):TrUtils.FixPriceValue(invoice.Amt, DecimalsNumber), alignment: 'right' });
+                body.push(dataRow);
+        });
+        return body;
+    }
+
+    static GetHeaderNames(ispur:boolean) {
+        let HeadingNames: any;
+            HeadingNames = [[{ text: 'S.No', style: 'tableheader1', Field: 'SNo', alignment: 'left', line: true },
+            { text: 'Transaction #', style: 'tableheader1', Field: 'Code' },
+            { text: ispur?'Vendor Name':'Customer Name', style: 'tableheader1', Field: 'Name',alignment: 'left' },
+
+            // { text:  ispur?'Bill No':'Invoice No', style: 'tableheader1', Field: 'InvCode' },
+            { text: 'Payment Date', style: 'tableheader1', Field: 'Date' },
+            { text: 'Payment Type', style: 'tableheader1', Field: 'Type' },
+            // { text: 'Offer Qty', style: 'tableheader1', Field: 'OfQty', alignment: 'right' },
+            // { text: 'Amount', style: 'tableheader1', Field: 'UnAmt', alignment: 'right' },
+            { text: 'Amount Paid', style: 'tableheader1', Field: 'Total', alignment: 'right' }
+            // { text: 'Total', style: 'tableheader1', Field: 'Total', alignment: 'right' }
+        ]];
+        return HeadingNames;
+    }
+
+}

package/src/aggregation/aggregation.ts

@@ -0,0 +1,58 @@
+import { TrUtils } from '../utils/tr-utils';
+const Big = require('big.js');
+
+export function addition(num1: number, num2: number, ...params: number[]) {
+    num1=TrUtils.SetValueToZeroIfNull(num1);
+    num2=TrUtils.SetValueToZeroIfNull(num2);
+    const bigNo1 = Big(num1);
+    const bigNo2 = Big(num2);
+    let resp = bigNo1.plus(bigNo2);
+    params.forEach((param: any) => {
+        param=TrUtils.SetValueToZeroIfNull(param);
+        const paramNo = Big(param);
+        resp = resp.plus(paramNo);
+    });
+    return resp.toNumber();
+}
+
+export function subtraction(num1: number, num2: number, ...params: number[]) {
+    num1=TrUtils.SetValueToZeroIfNull(num1);
+    num2=TrUtils.SetValueToZeroIfNull(num2);
+    const bigNo1 = Big(num1);
+    const bigNo2 = Big(num2);
+    let resp = bigNo1.minus(bigNo2);
+    params.forEach((param: any) => {
+        param=TrUtils.SetValueToZeroIfNull(param);
+        const paramNo = Big(param);
+        resp = resp.minus(paramNo);
+    });
+    return resp.toNumber();
+}
+
+export function multiply(num1: number, num2: number, ...params: number[]) {
+    num1=TrUtils.SetValueToZeroIfNull(num1);
+    num2=TrUtils.SetValueToZeroIfNull(num2);
+    const bigNo1 = Big(num1);
+    const bigNo2 = Big(num2);
+    let resp = bigNo1.mul(bigNo2);
+    params.forEach((param: any) => {
+        param=TrUtils.SetValueToZeroIfNull(param);
+        const paramNo = Big(param);
+        resp = resp.mul(paramNo);
+    });
+    return resp.toNumber();
+}
+
+export function division(num1: number, num2: number, ...params: number[]) {
+    num1=TrUtils.SetValueToZeroIfNull(num1);
+    num2=TrUtils.SetValueToZeroIfNull(num2);
+    const bigNo1 = Big(num1);
+    const bigNo2 = Big(num2);
+    let resp = bigNo1.div(bigNo2);
+    params.forEach((param: any) => {
+        param=TrUtils.SetValueToZeroIfNull(param);
+        const paramNo = Big(param);
+        resp = resp.div(paramNo);
+    });
+    return resp.toNumber();
+}

package/src/appointments/appointments/appointment-total.service.ts

@@ -0,0 +1,298 @@
+import { LaborStatusEnum, PayTypeEnum } from "../../enums/enums";
+import { Add, Subtract } from "../../shared/math-operations";
+import { TrUtils } from "../../utils/tr-utils";
+
+
+
+
+export class AppointmentTotalsService {
+
+    static GetTotalsValue(OriRecordData: any, TaxCodes: any[], detailedInfo: boolean, withItems: boolean, EntitySettings: any) {
+
+        let dupRecordData: any = TrUtils.Stringify(OriRecordData);
+
+        let argRecordData: any = {};
+
+        dupRecordData.Ops = this.CalculateLaborValues(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax));
+
+        argRecordData = this.GetROTotalsData(argRecordData, dupRecordData, TaxCodes, withItems, detailedInfo, EntitySettings.DecimalsNumber);
+
+        return argRecordData;
+    }
+
+    static CalculateLaborValues(opCodesList: any, isTaxable: boolean) {
+
+        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: any[]) {
+        opCodesList = opCodesList.filter((Labor: any) => {
+            return Labor.Sts !== LaborStatusEnum.Cancelled && Labor.Sts !== LaborStatusEnum.Declined;
+        });
+        return opCodesList;
+    }
+
+    static ResetLaborValuesIfInvalid(opCodesList: any) {
+        opCodesList.forEach((Operation: any) => {
+            Operation = this.ResetLaborValueIfInvalid(Operation);
+        });
+        return opCodesList;
+    }
+
+    static ResetLaborValueIfInvalid(Operation: any) {
+        Operation.Perc = TrUtils.SetPercToStringIfNull(Operation.Perc);
+        Operation.Disc = TrUtils.SetValueToZeroIfNull(Operation.Disc);
+        Operation.Pr = TrUtils.SetValueToZeroIfNull(Operation.Pr);
+        Operation.CCGST = TrUtils.SetValueToZeroIfNull(Operation.CCGST);
+        Operation.CSGST = TrUtils.SetValueToZeroIfNull(Operation.CSGST);
+        Operation.CIGST = TrUtils.SetValueToZeroIfNull(Operation.CIGST);
+        Operation.NetAmt = TrUtils.SetValueToZeroIfNull(Operation.NetAmt);
+        Operation.RecDisc = TrUtils.SetValueToZeroIfNull(Operation.RecDisc);
+        return Operation;
+    }
+
+    static GetOperationsDiscountPrice(OperationsList: any) {
+        OperationsList.forEach((Operation: any) => {
+
+            Operation.CustDiscountedPrice = Operation.Disc + Operation.RecDisc;
+
+        });
+        return OperationsList;
+    }
+
+    static GetOperationsAfterDiscount(OperationsList: any) {
+        OperationsList.forEach((Operation: any) => {
+            let CustAfterLaborDisc: number = 0;
+            if (Operation.PBy === PayTypeEnum.Customer) {
+                CustAfterLaborDisc = Operation.NetAmt;
+
+            } else {
+                CustAfterLaborDisc = Operation.NetAmt;
+            }
+            Operation.CustAfterLaborDisc = CustAfterLaborDisc;
+        });
+        return OperationsList;
+    }
+
+    static GetOperationsAfterTax(OperationsList: any, isTaxable: boolean) {
+        OperationsList.forEach((Operation: any) => {
+            if (!isTaxable) {
+                Operation.CustAfterTax = Operation.CustAfterLaborDisc;
+            } else {
+                if (Operation.PBy === 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: any, dupRecordData: any, TaxCodes: any, withItems: boolean, detailedInfo: any, DecimalsNumber: number) {
+
+        dupRecordData = this.ResetDiscountValuesIfInvalid(dupRecordData);
+
+        argRecordData = this.SetMainDiscountValues(argRecordData, dupRecordData, detailedInfo);
+
+        argRecordData = this.GetFinalCustomerTotalsData(argRecordData, dupRecordData, detailedInfo, DecimalsNumber);
+
+        if (detailedInfo) {
+            argRecordData = this.GetDetailedTotalsData(argRecordData, dupRecordData, TaxCodes, DecimalsNumber);
+        }
+
+        if (withItems) {
+            argRecordData.Ops = dupRecordData.Ops;
+        }
+
+        return argRecordData;
+    }
+
+    static ResetDiscountValuesIfInvalid(dupRecordData: any) {
+        dupRecordData.LPerc = TrUtils.SetPercToStringIfNull(dupRecordData.LPerc);
+        dupRecordData.Perc = TrUtils.SetPercToStringIfNull(dupRecordData.Perc);
+        dupRecordData.LDisc = TrUtils.SetValueToZeroIfNull(dupRecordData.LDisc);
+        dupRecordData.Disc = TrUtils.SetValueToZeroIfNull(dupRecordData.Disc);
+        return dupRecordData;
+    }
+
+    static SetMainDiscountValues(argRecordData: any, dupRecordData: any, detailedInfo: boolean) {
+        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: any, dupRecordData: any, detailedInfo: boolean, DecimalsNumber: number) {
+        let CustomerAfterDiscTotals: number = this.GetCustSubTotal(dupRecordData.Ops);
+
+        let CustLaborTaxTotal = this.GetCustLaborTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        let CustLaborDiscTotal: any = this.GetCustLaborDiscountedTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData, DecimalsNumber);
+        let CustLaborTotalAfterDisc: any = this.GetCustLaborTotalAfterDiscount(dupRecordData.Ops);
+        argRecordData.STotal = TrUtils.FixPriceValue(Add(CustLaborDiscTotal, CustLaborTotalAfterDisc), DecimalsNumber);
+        argRecordData.CustLaborTotalBeforeDisc = TrUtils.FixedTo(Add(argRecordData.CustLaborTotalAfterDisc
+            , argRecordData.CustLaborDiscTotal, DecimalsNumber));
+        argRecordData.SubTotal = TrUtils.FixedTo(CustomerAfterDiscTotals, DecimalsNumber);
+        let CustTotal: any = this.GetCustomerTotalBasedOnTaxType(dupRecordData, CustLaborTaxTotal, dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), DecimalsNumber);
+        if (detailedInfo) {
+            argRecordData.FixedSubTotal = TrUtils.FixedTo(CustomerAfterDiscTotals, DecimalsNumber);
+            argRecordData.FixedTotal = TrUtils.FixedTo(CustTotal, DecimalsNumber);
+        }
+        argRecordData.Round = TrUtils.FixedTo(Subtract(Math.round(CustTotal),  CustTotal), DecimalsNumber);
+        argRecordData.Total = Math.round(CustTotal);
+        return argRecordData;
+    }
+
+    static GetCustSubTotal(LaborList: any) {
+        let LaborTotalAfterDisc: any = this.GetCustLaborTotalAfterDiscount(LaborList);
+        return LaborTotalAfterDisc;
+    }
+
+    static GetCustLaborTotalAfterDiscount(LaborList: any) {
+        let LaborTotalAfterDisc: any = 0;
+        LaborList.forEach((Labor: any) => {
+            LaborTotalAfterDisc += Labor.CustAfterLaborDisc;
+        });
+        return LaborTotalAfterDisc;
+    }
+
+    static GetCustLaborTaxTotal(opCodesList: any, IsTaxable: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor: any) => {
+                TotalTaxAmt = TotalTaxAmt + Labor.CCGST + Labor.CSGST + Labor.CIGST;
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetCustomerTotalBasedOnTaxType(dupRecordData: any, LaborTaxAmount: number, LaborList: any, IsTaxable: boolean, DecimalsNumber: number) {
+        let SubTotalWithTax: any = 0;
+        let LaborTotalAfterDisc: any = this.GetCustLaborTotalAfterDiscount(LaborList);
+        if (IsTaxable) {
+            SubTotalWithTax = Add(LaborTotalAfterDisc, LaborTaxAmount);
+        } else {
+            SubTotalWithTax = TrUtils.FixedTo(Subtract(LaborTotalAfterDisc - dupRecordData.LDisc, dupRecordData.Disc), DecimalsNumber);
+        }
+        return SubTotalWithTax;
+    }
+
+    static GetDetailedTotalsData(argRecordData: any, dupRecordData: any, TaxCodes: any, DecimalsNumber: number) {
+        argRecordData.CustLaborDiscTotal = this.GetCustLaborDiscountedTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData, DecimalsNumber);
+        argRecordData.CustLaborTotalAfterDisc = this.GetCustLaborTotalAfterDiscount(dupRecordData.Ops);
+        argRecordData.CustLaborTotalBeforeDisc = TrUtils.FixedTo(Add(argRecordData.CustLaborTotalAfterDisc, argRecordData.CustLaborDiscTotal), DecimalsNumber);
+        argRecordData.CustLaborITax = this.GetCustLaborTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        argRecordData.CustLaborSGST = this.GetCustLaborSGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        argRecordData.CustLaborCGST = this.GetCustLaborCGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        argRecordData.CustLaborIGST = this.GetCustLaborIGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax));
+        argRecordData.CustLaborLDiscAmount = this.GetLaborLDiscAmount(argRecordData.CustLaborTotalAfterDisc, argRecordData.LDisc);
+        argRecordData.CustLaborAfterLDisc = argRecordData.CustLaborTotalAfterDisc;
+        argRecordData.CustLaborAfterTax = TrUtils.FixedTo(Add(argRecordData.CustLaborITax, argRecordData.CustLaborAfterLDisc), DecimalsNumber);
+        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] = TrUtils.FixPriceValue(argRecordData[key], DecimalsNumber);
+            }
+        }
+        return argRecordData;
+    }
+
+    static GetCustLaborDiscountedTotal(LaborList: any, isTaxable: boolean, finalTotalsData: any, DecimalsNumber: number) {
+        let LaborDiscountedTotal: any = 0;
+        let overallLaborDisc: number = 0;
+        if (!isTaxable) {
+            overallLaborDisc = TrUtils.SetValueToZeroIfNull(finalTotalsData.LDisc)
+        }
+        LaborList.forEach((Labor: any) => {
+            LaborDiscountedTotal += Labor.CustDiscountedPrice;
+        });
+        return TrUtils.FixedTo(Add(LaborDiscountedTotal, overallLaborDisc), DecimalsNumber);
+    }
+
+    static GetCustLaborCGSTTaxTotal(opCodesList: any, IsTaxable: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor: any) => {
+                TotalTaxAmt = Add(TotalTaxAmt, Labor.CCGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetCustLaborIGSTTaxTotal(opCodesList: any, IsTaxable: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor: any) => {
+                TotalTaxAmt = Add(TotalTaxAmt, Labor.CIGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetCustLaborSGSTTaxTotal(opCodesList: any, IsTaxable: boolean) {
+        let TotalTaxAmt: any = 0;
+        if (IsTaxable) {
+            opCodesList.forEach((Labor: any) => {
+                TotalTaxAmt = Add(TotalTaxAmt, Labor.CSGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+
+    static GetLaborLDiscAmount(LaborTotalAfterDisc: any, LDisc: any) {
+        let LaborLDiscAmt: any = 0;
+        if (!TrUtils.IsZero(LaborTotalAfterDisc)) {
+            LaborLDiscAmt = LDisc;
+        }
+        return LaborLDiscAmt;
+    }
+
+    static GetGSTValueBasedOnTaxCode(TCode: any, TaxCodes: any) {
+        let CGST: number = 0;
+        let SGST: number = 0;
+        let IGST: number = 0;
+        if (TrUtils.IsNull(TCode)) {
+            return [CGST, SGST, IGST];
+        }
+        let TCodeIndex: any = TaxCodes.findIndex((TaxCode: any) => {
+            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];
+        }
+    }
+
+}