shareneus 1.0.5

package/dist/services/purchase-order-print.service.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PurchaseOrderPrintService = void 0;
+const code_enums_1 = require("../enums/code-enums");
+const my_date_1 = require("../utils/my-date");
+const tr_utils_1 = require("../utils/tr-utils");
+const purchase_order_totals_service_1 = require("./purchase-order-totals.service");
+const shared_print_service_1 = require("./shared-print.service");
+class PurchaseOrderPrintService {
+    //Prepare Pdf Data For Purchase Order And Bill
+    static GetDataForPurchaseOrderPrint(argPurchaseOrderData, EntityData, image, VendorData, TaxCodes, IsFormPO) {
+        let PurchaseOrderData = tr_utils_1.TrUtils.Stringify(argPurchaseOrderData);
+        let PurchaseOrderPDFData = {};
+        PurchaseOrderPDFData.Settings = tr_utils_1.TrUtils.Stringify(argPurchaseOrderData.Settings);
+        PurchaseOrderPDFData.Adjust = argPurchaseOrderData.Adjust;
+        // let IsTaxable: boolean = (PurchaseOrderData.Tax === 3) ? true : false;
+        let IsTaxable = true;
+        // PurchaseOrderPDFData.ShowTaxColumn = (PurchaseOrderData.Tax === 3) ? true : false;
+        // PurchaseOrderPDFData.HasTaxIncluded = (PurchaseOrderData.Tax === 2) ? true : false;
+        // PurchaseOrderPDFData.HideDiscountColumn = (PurchaseOrderData.Tax === 2) ? true : false;
+        PurchaseOrderPDFData.ShowTaxColumn = true;
+        PurchaseOrderPDFData.HasTaxIncluded = false;
+        PurchaseOrderPDFData.HideDiscountColumn = false;
+        let SType;
+        if (!tr_utils_1.TrUtils.IsNull(argPurchaseOrderData.Settings) && !tr_utils_1.TrUtils.IsNull(argPurchaseOrderData.Settings.PoS)) {
+            SType = argPurchaseOrderData.Settings.PoS.SType;
+        }
+        // PurchaseOrderPDFData.HasNoTax = (PurchaseOrderData.Tax === 1) ? true : false;
+        PurchaseOrderPDFData.HasNoTax = false;
+        PurchaseOrderPDFData.ShowIGST = (tr_utils_1.TrUtils.IsNull(SType) || (SType === 'Intra')) ? false : true;
+        if (IsFormPO) {
+            PurchaseOrderPDFData.Id = PurchaseOrderData.Code;
+            PurchaseOrderPDFData.CrDate = my_date_1.MyDate.ConvertUTCDateToReadable(PurchaseOrderData.CrDate);
+            PurchaseOrderPDFData.DeDate = my_date_1.MyDate.ConvertUTCDateToReadable(PurchaseOrderData.DeDate);
+        }
+        else {
+            PurchaseOrderPDFData.Id = PurchaseOrderData.BNo;
+            PurchaseOrderPDFData.CrDate = my_date_1.MyDate.ConvertUTCDateToReadable(PurchaseOrderData.CrDate);
+            PurchaseOrderPDFData.DeDate = my_date_1.MyDate.ConvertUTCDateToReadable(PurchaseOrderData.DeDate);
+        }
+        PurchaseOrderPDFData.Items = tr_utils_1.TrUtils.Stringify(PurchaseOrderData.Items);
+        // PurchaseOrderPDFData.Items = this.GetPartsDescription(PurchaseOrderPDFData.Items);
+        PurchaseOrderPDFData.Items = this.GetQtyWithUoM(PurchaseOrderPDFData.Items);
+        let DetailedTotalsInfo;
+        if (IsFormPO) {
+            DetailedTotalsInfo = purchase_order_totals_service_1.PurchaseOrderTotalsService.GetTotalsValue(PurchaseOrderPDFData.Items, IsTaxable, true, TaxCodes, PurchaseOrderPDFData.Tax, true, PurchaseOrderPDFData.HasNoTax, false, 0, false, PurchaseOrderPDFData.Adjust);
+        }
+        else {
+            DetailedTotalsInfo = purchase_order_totals_service_1.PurchaseOrderTotalsService.GetTotalsValue(PurchaseOrderPDFData.Items, IsTaxable, true, TaxCodes, PurchaseOrderPDFData.Tax, true, PurchaseOrderPDFData.HasNoTax, true, PurchaseOrderData.Disc, PurchaseOrderData.Perc, PurchaseOrderPDFData.Adjust);
+        }
+        PurchaseOrderPDFData = this.ConcatTotalsInfo(PurchaseOrderPDFData, DetailedTotalsInfo);
+        PurchaseOrderPDFData.Entity = shared_print_service_1.PrintSharedService.GetFormattedEntityDataForPrint(EntityData, code_enums_1.PrintTypesEnum.PurOrder, PurchaseOrderData);
+        PurchaseOrderPDFData = shared_print_service_1.PrintSharedService.GetEntityHeaderStyles(PurchaseOrderPDFData, EntityData, image);
+        if (IsFormPO) {
+            PurchaseOrderPDFData.HeaderName = 'Purchase Order';
+        }
+        else {
+            if (argPurchaseOrderData.Expense) {
+                PurchaseOrderPDFData.HeaderName = 'Expense';
+            }
+            else {
+                PurchaseOrderPDFData.HeaderName = 'Bill';
+            }
+        }
+        PurchaseOrderPDFData.Vendor = this.GetVendorDataForPrint(tr_utils_1.TrUtils.Stringify(VendorData));
+        PurchaseOrderPDFData = this.FixPriceValuesForPrint(PurchaseOrderPDFData, TaxCodes);
+        return PurchaseOrderPDFData;
+    }
+    static GetVendorDataForPrint(argVendorData) {
+        if (tr_utils_1.TrUtils.IsNull(argVendorData)) {
+            return null;
+        }
+        let VendorPDFData = {};
+        let VendorData = tr_utils_1.TrUtils.Stringify(argVendorData);
+        // VendorPDFData.VendorType = VendorData.Type;
+        // if (VendorData.Type === CustomerTypesEnum.Individual) {
+        VendorPDFData.Name = VendorData.Name;
+        VendorPDFData.Contact = [
+            { Type: 'M', No: VendorData.Ph }
+        ];
+        // } else {
+        //     VendorPDFData.Name = VendorData.CName;
+        //     VendorPDFData.Contact = [
+        //         { Type: 'M', No: VendorData.MPhone }
+        //     ]
+        // }
+        VendorPDFData.Address = [];
+        if (!tr_utils_1.TrUtils.IsNull(VendorData.Adrs)) {
+            VendorPDFData.Address.push(VendorData.Adrs.A1);
+            if (!tr_utils_1.TrUtils.IsEmpty(VendorData.Adrs.A2)) {
+                VendorPDFData.Address.push(VendorData.Adrs.A2);
+            }
+            VendorPDFData.Address.push(VendorData.Adrs.Ct);
+        }
+        return VendorPDFData;
+    }
+    static GetQtyWithUoM(Items) {
+        Items.forEach((Part) => {
+            if (tr_utils_1.TrUtils.IsNull(Part.Ind)) {
+                if (!tr_utils_1.TrUtils.IsZero(Part.Qty) && !tr_utils_1.TrUtils.CheckInvalidSelect(Part.UoM)) {
+                    Part.QtyAndUoM = Part.Qty + ' ' + Part.UoM;
+                }
+            }
+            else {
+                if (tr_utils_1.TrUtils.IsNull(Part.OpCode)) {
+                    if (!tr_utils_1.TrUtils.IsZero(Part.Qty) && !tr_utils_1.TrUtils.CheckInvalidSelect(Part.UoM)) {
+                        Part.QtyAndUoM = Part.Qty + ' ' + Part.UoM;
+                    }
+                }
+            }
+        });
+        return Items;
+    }
+    static ConcatTotalsInfo(PurchaseOrderPDFData, DetailedTotalsInfo) {
+        PurchaseOrderPDFData = tr_utils_1.TrUtils.ConcatObjects(PurchaseOrderPDFData, DetailedTotalsInfo);
+        return PurchaseOrderPDFData;
+    }
+    static FixPriceValuesForPrint(PrintData, TaxCodes) {
+        PrintData.ShowDetailedPartTaxInfo = false;
+        PrintData.Items.forEach((Part) => {
+            if (tr_utils_1.TrUtils.IsNull(Part.UnCo)) {
+                Part.UnCo = Part.UnPr;
+            }
+            Part.UnCo = tr_utils_1.TrUtils.FixPriceValue(Part.UnCo);
+            Part.DiscountedPrice = tr_utils_1.TrUtils.FixPriceValue(Part.DiscountedPrice);
+            Part.AfterTax = tr_utils_1.TrUtils.FixPriceValue(Part.AfterTax);
+            Part.CGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Part.CGST);
+            Part.IGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Part.IGST);
+            Part.SGSTAmt = tr_utils_1.TrUtils.FixPriceValue(Part.SGST);
+            if (!tr_utils_1.TrUtils.CheckInvalidSelect(Part.TCode)) {
+                PrintData.ShowDetailedPartTaxInfo = true;
+            }
+            Part.CGSTPerc = shared_print_service_1.PrintSharedService.GetCGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+            Part.SGSTPerc = shared_print_service_1.PrintSharedService.GetSGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+            Part.IGSTPerc = shared_print_service_1.PrintSharedService.GetIGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+        });
+        PrintData.PartsDiscTotal = tr_utils_1.TrUtils.FixPriceValue(PrintData.PartsDiscTotal);
+        PrintData.PartsTotalAfterDisc = tr_utils_1.TrUtils.FixPriceValue(PrintData.PartsTotalAfterDisc);
+        PrintData.PartsTotalBeforeDisc = tr_utils_1.TrUtils.FixPriceValue(PrintData.PartsTotalBeforeDisc);
+        PrintData.TaxTotal = tr_utils_1.TrUtils.FixPriceValue(PrintData.TaxTotal);
+        PrintData.PartCGST = tr_utils_1.TrUtils.FixPriceValue(PrintData.PartCGST);
+        PrintData.PartIGST = tr_utils_1.TrUtils.FixPriceValue(PrintData.PartIGST);
+        PrintData.PartSGST = tr_utils_1.TrUtils.FixPriceValue(PrintData.PartSGST);
+        PrintData.PartAfterTax = tr_utils_1.TrUtils.FixPriceValue(PrintData.PartAfterTax);
+        PrintData.TotalRoundedBy = tr_utils_1.TrUtils.FixPriceValue(PrintData.TotalRoundedBy);
+        PrintData.RoundedTotal = tr_utils_1.TrUtils.FixPriceValue(PrintData.RoundedTotal);
+        return PrintData;
+    }
+}
+exports.PurchaseOrderPrintService = PurchaseOrderPrintService;

package/dist/services/purchase-order-totals.service.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PurchaseOrderTotalsService = void 0;
+const aggregation_1 = require("../aggregation/aggregation");
+const code_enums_1 = require("../enums/code-enums");
+const tr_utils_1 = require("../utils/tr-utils");
+class PurchaseOrderTotalsService {
+    static GetTotalsValue(argPartsList, IsTaxable, DetailedTotalsInfo, TaxCodes, Tax, ReturnPartsAlso, HasNoTax, GetSubTotal, Discount, DiscInPerc, Adjust) {
+        let PartsList = tr_utils_1.TrUtils.IsNull(argPartsList) ? [] : tr_utils_1.TrUtils.Stringify(argPartsList);
+        // PartsList = this.ResetPartValuesIfInvalid(PartsList);
+        // PartsList = this.GetPartsDiscountPrice(PartsList);
+        // PartsList = this.GetPartsAfterDiscount(PartsList);
+        PartsList = this.GetPartsTaxAmount(PartsList, IsTaxable, TaxCodes);
+        // PartsList = this.GetPartsAfterTax(PartsList);
+        let finalTotalsData = this.GetTotalsInfo(PartsList, IsTaxable, TaxCodes, HasNoTax, GetSubTotal, Discount, DiscInPerc, Adjust);
+        if (ReturnPartsAlso) {
+            finalTotalsData.Items = PartsList;
+        }
+        if (DetailedTotalsInfo === true) {
+            finalTotalsData = this.GetDetailedTotalsData(finalTotalsData, IsTaxable, PartsList, TaxCodes, Tax, HasNoTax);
+        }
+        return finalTotalsData;
+    }
+    static CheckPartStatusAndReturn(PartsList) {
+        PartsList = PartsList.filter((Part) => {
+            return Part.Sts !== code_enums_1.POPartStatusEnum.Del && Part.Sts !== code_enums_1.POPartStatusEnum.Deleted;
+        });
+        return PartsList;
+    }
+    static ResetPartValueIfInvalid(Part) {
+        // if (TrUtils.IsNull(Part.Ind)) {
+        if (tr_utils_1.TrUtils.IsNull(Part.UnCo)) {
+            Part.UnCo = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.UnPr);
+        }
+        Part.UnCo = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.UnCo);
+        Part.Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.Disc);
+        Part.SGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.SGST);
+        Part.IGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.IGST);
+        Part.CGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(Part.CGST);
+        // }
+        return Part;
+    }
+    static GetPartDiscountedPrice(Disc, RecDisc) {
+        // if (DiscInPerc) {
+        //     return TrUtils.FixedTo(((Price * Qty) * Disc) / 100);
+        // } else {
+        return (0, aggregation_1.addition)(Disc, tr_utils_1.TrUtils.SetValueToZeroIfNull(RecDisc));
+        // }
+    }
+    static GetPartsTaxAmount(Items, IsTaxable, TaxCodes) {
+        Items.forEach((Part) => {
+            Part = this.ResetPartValueIfInvalid(Part);
+            // Part.CGSTAmt = this.GetCGSTTaxAmount(Part.AfterDiscountPrice, IsTaxable, Part.TCode, TaxCodes);
+            // Part.IGSTAmt = this.GetIGSTTaxAmount(Part.AfterDiscountPrice, IsTaxable, Part.TCode, TaxCodes);
+            // Part.SGSTAmt = this.GetSGSTTaxAmount(Part.AfterDiscountPrice, IsTaxable, Part.TCode, TaxCodes);
+            if (tr_utils_1.TrUtils.IsNull(Part.Ind)) {
+                Part.DiscountedPrice = this.GetPartDiscountedPrice(Part.Disc, Part.RecDisc);
+                Part.AfterDiscountPrice = Part.NetAmt;
+            }
+            Part.GSTAmt = (0, aggregation_1.addition)(Part.SGST, Part.CGST, Part.IGST);
+            Part.Desc = Part.Name;
+            let Price = 0;
+            if (IsTaxable) {
+                // if (!TrUtils(Part.Perc)) {
+                Price = (0, aggregation_1.multiply)(Part.UnCo, Part.Qty);
+                Part.LineTotal = tr_utils_1.TrUtils.FixedTo((0, aggregation_1.addition)((0, aggregation_1.subtraction)(Price, Part.Disc), Part.GSTAmt));
+                // } else {
+                //     Part.LineTotal = TrUtils.FixedTo((Part.UnPr - Part.Disc) + Part.GSTAmt);
+                // }
+            }
+            else {
+                // let DiscPrice: any = 0;
+                // if (Part.Perc) {
+                Price = (0, aggregation_1.multiply)(Part.UnCo, Part.Qty);
+                Part.LineTotal = tr_utils_1.TrUtils.FixedTo((0, aggregation_1.subtraction)(Price, Part.Disc));
+                // } else {
+                //     Part.LineTotal = TrUtils.FixedTo((Part.UnPr - Part.Disc));
+                // }
+            }
+            Part.AfterTax = (0, aggregation_1.addition)(Part.AfterDiscountPrice, Part.GSTAmt);
+        });
+        return Items;
+    }
+    static GetGSTValueBasedOnTaxCode(TCode, argTaxCodes) {
+        if (tr_utils_1.TrUtils.IsNull(TCode)) {
+            return [0, 0, 0];
+        }
+        let TaxCodes = tr_utils_1.TrUtils.Stringify(argTaxCodes);
+        let TCodeIndex = TaxCodes.findIndex((TaxCode) => {
+            return TaxCode._id === Number(TCode);
+        });
+        if (TCodeIndex !== -1) {
+            // // if (TrUtils.IsNull(TaxCodes[TCodeIndex].CGST)) {
+            // //     return 0;
+            // // } else {
+            // return [TaxCodes[TCodeIndex].CGST, TaxCodes[TCodeIndex].SGST, TaxCodes[TCodeIndex].IGST];
+            // // }
+            if (TaxCodes[TCodeIndex].Type === 'Intra') {
+                return [TaxCodes[TCodeIndex].CGST, TaxCodes[TCodeIndex].SGST, 0];
+            }
+            else {
+                return [0, 0, TaxCodes[TCodeIndex].IGST];
+            }
+        }
+        else {
+            return [0, 0, 0];
+        }
+    }
+    static GetTotalsInfo(PartsList, IsTaxable, TaxCodes, HasNoTax, GetSubTotal, Discount, DiscInPerc, Adjust) {
+        let finalTotalsData = {};
+        let PartsInfo = this.GetPartsTotalTaxAndAfterDiscount(PartsList);
+        let PartsTotalAfterDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(PartsInfo[0]);
+        let PartsDiscTotal = tr_utils_1.TrUtils.SetValueToZeroIfNull(PartsInfo[1]);
+        let PartsTaxTotal = tr_utils_1.TrUtils.SetValueToZeroIfNull(PartsInfo[2]);
+        finalTotalsData.SubTotal = (0, aggregation_1.addition)(PartsTotalAfterDisc, PartsDiscTotal);
+        finalTotalsData.Adj = tr_utils_1.TrUtils.FixPriceValue(Adjust);
+        // if (GetSubTotal) {
+        //     finalTotalsData.SubTotal = this.GetTotalBasedOnTaxType(PartsTotalAfterDisc, PartsTaxTotal,
+        //         IsTaxable);
+        //     let Total: number = finalTotalsData.SubTotal;
+        //     if (HasNoTax && !TrUtils.IsNull(Discount)) {
+        //         if (DiscInPerc) {
+        //             Total = TrUtils.FixedTo(((finalTotalsData.SubTotal) -
+        //                 ((finalTotalsData.SubTotal) * Discount) / 100));
+        //         } else {
+        //             Total = TrUtils.FixedTo((finalTotalsData.SubTotal) - Discount);
+        //         }
+        //     }
+        //     finalTotalsData.Total = Total;
+        // } else {
+        finalTotalsData.Total = this.GetTotalBasedOnTaxType(PartsTotalAfterDisc, PartsTaxTotal, IsTaxable, Adjust);
+        // }
+        // finalTotalsData.Round = TrUtils.FixedTo(Math.round(finalTotalsData.Total) - finalTotalsData.Total);
+        // finalTotalsData.Total = Math.round(finalTotalsData.Total);
+        return finalTotalsData;
+    }
+    static GetPartsTotalTaxAndAfterDiscount(PartsList) {
+        let PartsTotalAfterDisc = 0;
+        let PartsDiscountedTotal = 0;
+        let TotalTaxAmt = 0;
+        PartsList.forEach((Part) => {
+            PartsTotalAfterDisc = (0, aggregation_1.addition)(PartsTotalAfterDisc, Part.AfterDiscountPrice);
+            PartsDiscountedTotal = (0, aggregation_1.addition)(PartsDiscountedTotal, Part.DiscountedPrice);
+            TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.GSTAmt);
+        });
+        return [PartsTotalAfterDisc, PartsDiscountedTotal, TotalTaxAmt];
+    }
+    static GetTotalBasedOnTaxType(PartsTotalAfterDisc, PartsTaxAmount, IsTaxable, Adjust) {
+        let Total = 0;
+        if (IsTaxable) {
+            Total = (0, aggregation_1.addition)(PartsTotalAfterDisc, PartsTaxAmount);
+        }
+        else {
+            Total = PartsTotalAfterDisc;
+        }
+        let finalTotal = (0, aggregation_1.addition)(Total, tr_utils_1.TrUtils.SetValueToZeroIfNull(Adjust));
+        return tr_utils_1.TrUtils.FixedTo(finalTotal);
+    }
+    static GetDetailedTotalsData(finalTotalsData, IsTaxable, PartsList, TaxCodes, Tax, HasNoTax) {
+        let PartsInfo = this.GetPartsTotalTaxAndAfterDiscount(PartsList);
+        finalTotalsData.PartsDiscTotal = tr_utils_1.TrUtils.SetValueToZeroIfNull(PartsInfo[1]);
+        finalTotalsData.PartsTotalAfterDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(PartsInfo[0]);
+        finalTotalsData.PartsTotalBeforeDisc = (0, aggregation_1.addition)(finalTotalsData.PartsTotalAfterDisc, finalTotalsData.PartsDiscTotal);
+        // finalTotalsData.TaxTotal = this.GetPartsTaxTotal(PartsList);
+        finalTotalsData.TaxTotal = tr_utils_1.TrUtils.SetValueToZeroIfNull(PartsInfo[2]);
+        let TaxAmt = this.GetPartGSTTaxTotal(PartsList);
+        // finalTotalsData.PartCGST = this.GetPartCGSTTaxTotal(PartsList);
+        // finalTotalsData.PartIGST = this.GetPartIGSTTaxTotal(PartsList);
+        // finalTotalsData.PartSGST = this.GetPartSGSTTaxTotal(PartsList);
+        finalTotalsData.PartCGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxAmt[0]);
+        finalTotalsData.PartSGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxAmt[1]);
+        finalTotalsData.PartIGST = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxAmt[2]);
+        finalTotalsData.PartAfterTax = (0, aggregation_1.addition)(finalTotalsData.PartsTotalAfterDisc, finalTotalsData.TaxTotal);
+        finalTotalsData.IsTaxable = IsTaxable;
+        finalTotalsData.Tax = Tax;
+        finalTotalsData.HasNoTax = HasNoTax;
+        finalTotalsData.TaxGroupData = this.GetPartsTaxGroupingFor(PartsList, TaxCodes);
+        // finalTotalsData.TotalRoundedBy = TrUtils.FixedTo(Math.round(finalTotalsData.Total) - finalTotalsData.Total);
+        finalTotalsData.RoundedTotal = Math.round(finalTotalsData.Total);
+        // finalTotalsData.Round = TrUtils.FixedTo(Math.round(finalTotalsData.Total) - finalTotalsData.Total);
+        // finalTotalsData.Total = Math.round(finalTotalsData.Total);
+        return finalTotalsData;
+    }
+    static GetPartGSTTaxTotal(PartsList) {
+        let CGSTAmt = 0;
+        let SGSTAmt = 0;
+        let IGSTAmt = 0;
+        PartsList.forEach((Part) => {
+            CGSTAmt = (0, aggregation_1.addition)(CGSTAmt, Part.CGST);
+            SGSTAmt = (0, aggregation_1.addition)(SGSTAmt, Part.SGST);
+            IGSTAmt = (0, aggregation_1.addition)(IGSTAmt, Part.IGST);
+        });
+        return [CGSTAmt, SGSTAmt, IGSTAmt];
+    }
+    static GetPartsTaxGroupingFor(PartsList, TaxCodes) {
+        return this.GetTaxGroupingForPartsByHSN(tr_utils_1.TrUtils.Stringify(PartsList), TaxCodes);
+    }
+    static GetTaxGroupingForPartsByHSN(Items, TaxCodes) {
+        Items = this.GetCombinedTaxPercentage(Items, TaxCodes);
+        // Items = this.ResetPartsHSNIfInvalid(Items);
+        let FinalMatchedParts = this.ComparePartsByHSN(Items, TaxCodes);
+        return this.GetTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes);
+    }
+    static GetCombinedTaxPercentage(Items, TaxCodes) {
+        Items.forEach((Part) => {
+            if (tr_utils_1.TrUtils.IsNull(Part.HSN)) {
+                Part.HSN = '';
+            }
+            let TaxInfo = this.GetGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+            Part.CGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[0]);
+            Part.SGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[1]);
+            Part.IGSTAmt = tr_utils_1.TrUtils.SetValueToZeroIfNull(TaxInfo[2]);
+            // Part.CGSTAmt = this.GetCGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+            // Part.SGSTAmt = this.GetSGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+            // Part.IGSTAmt = this.GetIGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+            Part.CombinedTaxPercentage = (0, aggregation_1.addition)(Part.CGSTAmt, Part.SGSTAmt, Part.IGSTAmt);
+        });
+        return Items;
+    }
+    static ComparePartsByHSN(Items, TaxCodes) {
+        let FinalMatchedParts = [];
+        Items.forEach((Part) => {
+            let MatchedPartsBasedOnHSN = Items.filter((argPart) => {
+                let PartFound = false;
+                FinalMatchedParts.forEach((FinalArgParts) => {
+                    let PartIndex = FinalArgParts.findIndex((FinalArgPart) => {
+                        return FinalArgPart._id === argPart._id;
+                    });
+                    if (PartIndex !== -1) {
+                        PartFound = true;
+                    }
+                });
+                // let argCGST = this.GetCGSTValueBasedOnTaxCode(argPart.TCode, TaxCodes);
+                // let argSGST = this.GetSGSTValueBasedOnTaxCode(argPart.TCode, TaxCodes);
+                // let argIGST = this.GetIGSTValueBasedOnTaxCode(argPart.TCode, TaxCodes);
+                // let partCGST = this.GetCGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+                // let partSGST = this.GetSGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+                // let partIGST = this.GetIGSTValueBasedOnTaxCode(Part.TCode, TaxCodes);
+                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.AfterDiscountPrice);
+                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.PartsCount = MatchedPart.length;
+            // let CGST = this.GetCGSTValueBasedOnTaxCode(MatchedPart[0].TCode, TaxCodes);
+            // let SGST = this.GetSGSTValueBasedOnTaxCode(MatchedPart[0].TCode, TaxCodes);
+            // let IGST = this.GetIGSTValueBasedOnTaxCode(MatchedPart[0].TCode, TaxCodes);
+            TaxInfo.CGST = MatchedPart[0].CGSTAmt;
+            TaxInfo.IGST = MatchedPart[0].IGSTAmt;
+            TaxInfo.SGST = MatchedPart[0].SGSTAmt;
+            if (TaxOnAmount !== 0) {
+                HSNTaxInfo.push(TaxInfo);
+            }
+        });
+        return HSNTaxInfo;
+    }
+}
+exports.PurchaseOrderTotalsService = PurchaseOrderTotalsService;

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceiptPrintService = void 0;
+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 ReceiptPrintService {
+    static GetReceiptPrint(argPaymentViewData, EntityData, image) {
+        let PaymentViewData = tr_utils_1.TrUtils.Stringify(argPaymentViewData);
+        let ReceiptData = {};
+        ReceiptData.Entity = shared_print_service_1.PrintSharedService.GetFormattedEntityDataForPrint(EntityData, "Receipt", argPaymentViewData);
+        ReceiptData = shared_print_service_1.PrintSharedService.GetEntityHeaderStyles(ReceiptData, EntityData, image);
+        ReceiptData.FullName = PaymentViewData.Name;
+        // if (PaymentViewData.PType === 'Cash') {
+        //     ReceiptData.TypeNumber = PaymentViewData.Amt;
+        // } else
+        if (PaymentViewData.PType === 'Cheque' || PaymentViewData.PType === 'MasterCard') {
+            ReceiptData.TypeNumber = PaymentViewData.CNo;
+        }
+        else if (PaymentViewData.PType === 'Visa') {
+            ReceiptData.TypeNumber = PaymentViewData.CNo;
+        }
+        else {
+            ReceiptData.TypeNumber = '';
+        }
+        ReceiptData.TotalAmount = PaymentViewData.Amt;
+        ReceiptData.PaidDate = my_date_1.MyDate.ConvertUTCDateToReadable(PaymentViewData.Date);
+        ReceiptData.Ids = this.GetRecordIds(PaymentViewData);
+        ReceiptData.Type = 'Receipt';
+        ReceiptData.HeaderName = 'Receipt';
+        ReceiptData.PaymentId = PaymentViewData.Code;
+        ReceiptData.PaymentType = PaymentViewData.PType;
+        return ReceiptData;
+    }
+    static GetRecordIds(PaymentViewData) {
+        let IdList = [];
+        var i = 0;
+        if (!tr_utils_1.TrUtils.IsNull(PaymentViewData.Invs) && PaymentViewData.Invs.length !== 0) {
+            for (i = 0; i < PaymentViewData.Invs.length; i++) {
+                let Id = PaymentViewData.Invs[i].Code;
+                if (!tr_utils_1.TrUtils.IsNull(PaymentViewData.Invs[i].RegNo)) {
+                    Id = Id + '(' + PaymentViewData.Invs[i].RegNo + ')';
+                }
+                IdList.push(Id);
+            }
+        }
+        return IdList;
+    }
+}
+exports.ReceiptPrintService = ReceiptPrintService;

package/dist/services/reorder-point-pdf.service.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReorderPointPDFService = void 0;
+const my_date_1 = require("../utils/my-date");
+const tr_utils_1 = require("../utils/tr-utils");
+class ReorderPointPDFService {
+    static GetPrint(ReOrderPointData) {
+        // console.log('ReOrderPointData', ReOrderPointData);
+        let dd = {
+            // info: {
+            //     title: this.GetFileName(ROPrintData),
+            // },
+            info: {
+                title: 'ReOrderPoint',
+            },
+            header: function (currentPage, pageCount, pageSize) {
+                return { text: currentPage.toString() + ' of ' + pageCount, alignment: 'right', marginRight: 25, fontSize: 8, marginTop: 2 };
+            },
+            pageMargins: [25, 15, 25, 15],
+            pageSize: 'A4',
+            content: [
+                { text: ReOrderPointData.Entity.CName, style: ['headerstyle'], alignment: 'center', fontSize: 20 },
+                { text: 'Reorder Point (' + 'As of ' + my_date_1.MyDate.ConvertUTCDateToReadable(my_date_1.MyDate.GetDateTimeNowInUTC()) + ')', style: ['headerstyle'], alignment: 'center', fontSize: 12 },
+                { text: 'Items need to be Ordered', style: ['headerstyle'], alignment: 'left', fontSize: 10, marginTop: 10, decoration: 'underline' },
+                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: {
+                    // margin: [0, 10, 30, 0],
+                    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
+                }
+            }
+        };
+        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: ['*', 70, 50, 50, '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) => {
+            var _a;
+            let dataRow = [];
+            let VName;
+            if (tr_utils_1.TrUtils.IsNull(item === null || item === void 0 ? void 0 : item.Vendor) || tr_utils_1.TrUtils.IsNull(item === null || item === void 0 ? void 0 : item.Vendor[0])) {
+                VName = '';
+            }
+            else {
+                VName = (_a = item === null || item === void 0 ? void 0 : item.Vendor[0]) === null || _a === void 0 ? void 0 : _a.DName;
+            }
+            dataRow.push({ text: item.Name, });
+            dataRow.push({ text: item.Qty, alignment: 'right', style: ['headerstyle'], });
+            dataRow.push({ text: item.Min, alignment: 'right', style: ['headerstyle'], });
+            dataRow.push({ text: item.Max, alignment: 'right', style: ['headerstyle'], });
+            dataRow.push({ text: VName, alignment: 'left', style: ['headerstyle'], });
+            body.push(dataRow);
+        });
+        return body;
+    }
+    static GetHeaderNames() {
+        let HeadingNames;
+        HeadingNames = [[{ text: 'Name', style: 'tableheader1', Field: 'Name', alignment: 'left', line: true },
+                { text: 'Qty On Hand', style: 'tableheader1', Field: 'Qty', alignment: 'right' },
+                { text: 'Min Qty', style: 'tableheader1', Field: 'Min', alignment: 'right' },
+                { text: 'Max Qty', style: 'tableheader1', Field: 'Max', alignment: 'right' },
+                { text: 'Vendor', style: 'tableheader1', Field: 'Vendor', alignment: 'left' },
+            ]];
+        return HeadingNames;
+    }
+}
+exports.ReorderPointPDFService = ReorderPointPDFService;