shareneus 1.4.95 → 1.4.97

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

@@ -0,0 +1,573 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SalesReceiveTotalsService = void 0;
+const tr_utils_1 = require("../utils/tr-utils");
+const aggregation_1 = require("../aggregation/aggregation");
+/**
+ * Service class for calculating sales receive totals including taxes, discounts and final amounts
+ */
+class SalesReceiveTotalsService {
+    /**
+     * Main method to calculate totals for sales receive operations
+     * @param opCodesList - Array of operation codes/labor items
+     * @param PartsList - Array of parts/items to be processed
+     * @param IsIndependentTax - Whether tax is calculated independently
+     * @param DetailedInfo - Whether to include detailed breakdown information
+     * @param Disc - Discount amount
+     * @param Perc - Discount percentage
+     * @param TaxCodes - Available tax codes for GST calculations
+     * @param WithItems - Whether to include items in the response
+     * @param Settings - General settings object
+     * @param EntitySettings - Entity-specific settings including decimal places
+     * @returns Object containing calculated totals and breakdown information
+     */
+    static GetTotalsValue(opCodesList, PartsList, IsIndependentTax, DetailedInfo, Disc, Perc, TaxCodes, WithItems, Settings, EntitySettings = {}) {
+        // Sanitize input parameters to ensure valid values
+        Perc = tr_utils_1.TrUtils.SetPercToStringIfNull(Perc);
+        Disc = tr_utils_1.TrUtils.SetValueToZeroIfNull(Disc);
+        // Calculate labor part values with tax considerations
+        PartsList = this.CalculateLaborPartValues(PartsList, IsIndependentTax);
+        // Get the main totals data
+        let finalTotalsData = this.GetFinalRODataForSave(opCodesList, PartsList, IsIndependentTax, Disc, Perc, DetailedInfo, Settings, EntitySettings.DecimalsNumber);
+        // Add detailed breakdown if requested
+        if (DetailedInfo) {
+            finalTotalsData = this.GetDetailedTotalsData(finalTotalsData, IsIndependentTax, opCodesList, PartsList, TaxCodes, EntitySettings.DecimalsNumber);
+        }
+        // Include items in response if requested
+        if (WithItems) {
+            finalTotalsData.Items = PartsList;
+        }
+        return finalTotalsData;
+    }
+    /**
+     * Calculates labor part values including discounts and taxes
+     * @param PartsList - Array of parts to be processed
+     * @param IsIndependentTax - Whether tax is calculated independently
+     * @returns Processed parts list with calculated values
+     */
+    static CalculateLaborPartValues(PartsList, IsIndependentTax) {
+        PartsList = this.ResetLaborPartValues(PartsList, IsIndependentTax);
+        return PartsList;
+    }
+    /**
+     * Resets and recalculates labor part values including discounts and taxes
+     * @param PartsList - Array of parts to be processed
+     * @param IsIndependentTax - Whether tax is calculated independently
+     * @returns Parts list with reset and recalculated values
+     */
+    static ResetLaborPartValues(PartsList, IsIndependentTax) {
+        PartsList.forEach((Part) => {
+            // Reset invalid values to defaults
+            Part = this.ResetLaborPartValueIfInvalid(Part);
+            // Set minimum quantity to 1 if zero
+            if (tr_utils_1.TrUtils.IsZero(Part.Qty)) {
+                Part.Qty = 1;
+            }
+            // Calculate total discounted price
+            Part.DiscountedPrice = (0, aggregation_1.addition)(Part.Disc, Part.RecDisc);
+            // Calculate amount after discount
+            Part.AfterPartDisc = (0, aggregation_1.subtraction)(Part.UnAmt, Part.Disc, Part.RecDisc);
+            // Calculate amount after tax based on tax type
+            if (IsIndependentTax) {
+                Part.AfterPartTax = (0, aggregation_1.addition)(Part.AfterPartDisc, Part.CGST, Part.SGST, Part.IGST);
+            }
+            else {
+                Part.AfterPartTax = Part.AfterPartDisc;
+            }
+        });
+        return PartsList;
+    }
+    /**
+     * Resets part values to zero if they are null or invalid
+     * @param Part - Individual part item to reset
+     * @returns Part with reset values
+     */
+    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;
+    }
+    /**
+     * Prepares final repair order data for saving with calculated totals
+     * @param LaborList - Array of labor items
+     * @param PartsList - Array of parts
+     * @param IsIndependentTax - Whether tax is calculated independently
+     * @param Disc - Discount amount
+     * @param Perc - Discount percentage
+     * @param DetailedInfo - Whether to include detailed information
+     * @param Settings - General settings
+     * @param DecimalsNumber - Number of decimal places for calculations
+     * @returns Final totals data object ready for saving
+     */
+    static GetFinalRODataForSave(LaborList, PartsList, IsIndependentTax, Disc, Perc, DetailedInfo, Settings, DecimalsNumber) {
+        let finalTotalsData = {};
+        // Set discount values
+        finalTotalsData = this.SetMainDiscountValues(Disc, Perc, finalTotalsData, DetailedInfo);
+        // Add settings to response
+        finalTotalsData.Settings = Settings;
+        // Calculate customer totals
+        finalTotalsData = this.GetFinalCustomerTotalsData(finalTotalsData, [], PartsList, IsIndependentTax, DetailedInfo, DecimalsNumber);
+        return finalTotalsData;
+    }
+    /**
+     * Sets main discount values in the totals data object
+     * @param Disc - Discount amount
+     * @param Perc - Discount percentage
+     * @param finalTotalsData - Totals data object to update
+     * @param DetailedInfo - Whether to include detailed information
+     * @returns Updated totals data with discount values
+     */
+    static SetMainDiscountValues(Disc, Perc, finalTotalsData, DetailedInfo) {
+        finalTotalsData.Disc = Disc;
+        finalTotalsData.Perc = Perc;
+        if (DetailedInfo) {
+            finalTotalsData.FixedDisc = Disc;
+        }
+        return finalTotalsData;
+    }
+    /**
+     * Calculates final customer totals including subtotals, taxes, and rounded amounts
+     * @param finalTotalsData - Existing totals data object
+     * @param LaborList - Array of labor items
+     * @param PartsList - Array of parts
+     * @param IsIndependentTax - Whether tax is calculated independently
+     * @param DetailedInfo - Whether to include detailed information
+     * @param DecimalsNumber - Number of decimal places for calculations
+     * @returns Updated totals data with customer calculations
+     */
+    static GetFinalCustomerTotalsData(finalTotalsData, LaborList, PartsList, IsIndependentTax, DetailedInfo, DecimalsNumber = 2) {
+        // Calculate subtotal after discounts
+        let CustomerAfterDiscTotals = this.GetSubTotalFor([], PartsList);
+        // Calculate parts tax total
+        let CustPartTaxTotal = this.GetPartsTaxTotalFor(PartsList, IsIndependentTax);
+        // Set subtotal with proper decimal formatting
+        finalTotalsData.SubTotal = tr_utils_1.TrUtils.FixedTo(CustomerAfterDiscTotals, DecimalsNumber);
+        // Calculate discount totals
+        let CustPartsDiscTotal = this.GetPartDiscountedTotal(PartsList, IsIndependentTax, finalTotalsData);
+        let CustPartsTotalAfterDisc = this.GetPartsTotalAfterDiscount(PartsList);
+        // Calculate sum total
+        finalTotalsData.STotal = (0, aggregation_1.addition)(CustPartsDiscTotal, CustPartsTotalAfterDisc);
+        // Calculate final customer total
+        let CustTotal = this.GetCustomerTotalBasedOnTaxType(finalTotalsData, 0, CustPartTaxTotal, [], PartsList, IsIndependentTax);
+        // Calculate rounding difference and final total
+        finalTotalsData.Round = (0, aggregation_1.subtraction)(Math.round(CustTotal), CustTotal);
+        finalTotalsData.Total = Math.round(CustTotal);
+        // Add detailed information if requested
+        if (DetailedInfo) {
+            finalTotalsData.FixedSubTotal = tr_utils_1.TrUtils.FixedTo(CustomerAfterDiscTotals, DecimalsNumber);
+            finalTotalsData.FixedTotal = tr_utils_1.TrUtils.FixedTo(CustTotal, DecimalsNumber);
+        }
+        return finalTotalsData;
+    }
+    /**
+     * Calculates subtotal for labor and parts combined
+     * @param LaborList - Array of labor items
+     * @param PartsList - Array of parts
+     * @returns Calculated subtotal amount
+     */
+    static GetSubTotalFor(LaborList, PartsList) {
+        let PartsTotalAfterDisc = this.GetPartsTotalAfterDiscount(PartsList);
+        return PartsTotalAfterDisc;
+    }
+    /**
+     * Calculates total amount for parts after applying discounts
+     * @param PartsList - Array of parts
+     * @returns Total parts amount after discounts
+     */
+    static GetPartsTotalAfterDiscount(PartsList) {
+        let PartsTotalAfterDisc = 0;
+        PartsList.forEach((Part) => {
+            PartsTotalAfterDisc = (0, aggregation_1.addition)(PartsTotalAfterDisc, Part.AfterPartDisc);
+        });
+        return PartsTotalAfterDisc;
+    }
+    /**
+     * Generates detailed totals data including tax breakdowns and groupings
+     * @param finalTotalsData - Existing totals data
+     * @param IsIndependentTax - Whether tax is calculated independently
+     * @param opCodesList - Array of operation codes
+     * @param PartsList - Array of parts
+     * @param TaxCodes - Available tax codes
+     * @param DecimalsNumber - Number of decimal places
+     * @returns Enhanced totals data with detailed breakdowns
+     */
+    static GetDetailedTotalsData(finalTotalsData, IsIndependentTax, opCodesList, PartsList, TaxCodes, DecimalsNumber = 2) {
+        // Add parts discount and total information
+        finalTotalsData.CustPartsDiscTotal = this.GetPartDiscountedTotal(PartsList, IsIndependentTax, finalTotalsData);
+        finalTotalsData.CustPartsTotalAfterDisc = this.GetPartsTotalAfterDiscount(PartsList);
+        finalTotalsData.CustPartsTotalBeforeDisc = (0, aggregation_1.addition)(finalTotalsData.CustPartsTotalAfterDisc, finalTotalsData.CustPartsDiscTotal);
+        // Get GST tax breakdown
+        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]);
+        // Calculate after tax amount
+        finalTotalsData.CustPartAfterTax = (0, aggregation_1.addition)(finalTotalsData.CustPartITax, finalTotalsData.CustPartsTotalAfterDisc);
+        // Add tax grouping information
+        finalTotalsData.CustTaxGroupData = this.GetTaxGroupingForPartsByHSN(tr_utils_1.TrUtils.Stringify(PartsList), TaxCodes, DecimalsNumber);
+        finalTotalsData.CustTaxGroupDataByPerc = this.GetTaxGroupingForPartsByPerc(PartsList, TaxCodes, DecimalsNumber);
+        // Add rounding information
+        finalTotalsData.CustTotalRoundedBy = tr_utils_1.TrUtils.FixedTo(finalTotalsData.Round, DecimalsNumber);
+        finalTotalsData.CustRoundedTotal = tr_utils_1.TrUtils.FixedTo(finalTotalsData.Total, DecimalsNumber);
+        // Format all numeric values to proper decimal places
+        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], DecimalsNumber);
+            }
+        }
+        return finalTotalsData;
+    }
+    /**
+     * Groups parts by tax percentage for consolidated tax reporting
+     * @param Parts - Array of parts to group
+     * @param TaxCodes - Available tax codes
+     * @param DecimalsNumber - Number of decimal places
+     * @returns Array of parts grouped by tax percentage
+     */
+    static GetTaxGroupingForPartsByPerc(Parts, TaxCodes, DecimalsNumber) {
+        // Add combined tax percentage to each part
+        Parts = this.GetCombinedTaxPercentage(tr_utils_1.TrUtils.Stringify(Parts), TaxCodes);
+        // Group parts with same tax percentages
+        let FinalMatchedParts = this.ComparePartsByPerc(Parts, TaxCodes);
+        // Generate tax grouping information
+        return this.GetTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes, DecimalsNumber);
+    }
+    /**
+     * Compares and groups parts by tax percentage rates
+     * @param Parts - Array of parts to compare
+     * @param TaxCodes - Available tax codes
+     * @returns Array of grouped parts with same tax percentages
+     */
+    static ComparePartsByPerc(Parts, TaxCodes) {
+        let FinalMatchedParts = [];
+        Parts === null || Parts === void 0 ? void 0 : Parts.forEach((Part) => {
+            // Find parts with matching tax amounts that haven't been grouped yet
+            let MatchedPartsBasedOnHSN = Parts.filter((argPart) => {
+                let PartFound = false;
+                // Check if part is already in a group
+                FinalMatchedParts.forEach((FinalArgParts) => {
+                    let PartIndex = FinalArgParts.findIndex((FinalArgPart) => {
+                        return FinalArgPart._id === argPart._id;
+                    });
+                    if (PartIndex !== -1) {
+                        PartFound = true;
+                    }
+                });
+                // Return parts with same tax percentages that aren't already grouped
+                return (!PartFound) &&
+                    (argPart.CGSTAmt === Part.CGSTAmt) && (argPart.IGSTAmt === Part.IGSTAmt) &&
+                    (argPart.SGSTAmt === Part.SGSTAmt);
+            });
+            // Add group if it contains parts
+            if (MatchedPartsBasedOnHSN.length !== 0) {
+                FinalMatchedParts.push(MatchedPartsBasedOnHSN);
+            }
+        });
+        return FinalMatchedParts;
+    }
+    /**
+     * Calculates total discounted amount for all parts
+     * @param PartsList - Array of parts
+     * @param isTaxable - Whether parts are taxable
+     * @param finalTotalsData - Existing totals data
+     * @returns Total discounted amount including overall part discount
+     */
+    static GetPartDiscountedTotal(PartsList, isTaxable, finalTotalsData) {
+        let PartsDiscountedTotal = 0;
+        let overallPartDisc = 0;
+        // Add overall part discount if not taxable
+        if (!isTaxable) {
+            overallPartDisc = tr_utils_1.TrUtils.SetValueToZeroIfNull(finalTotalsData.PDisc);
+        }
+        // Sum up individual part discounts
+        PartsList.forEach((Part) => {
+            PartsDiscountedTotal = (0, aggregation_1.addition)(PartsDiscountedTotal, Part.DiscountedPrice);
+        });
+        return (0, aggregation_1.addition)(PartsDiscountedTotal, overallPartDisc);
+    }
+    /**
+     * Calculates total tax amount for all parts
+     * @param PartsList - Array of parts
+     * @param IsIndependentTax - Whether tax is calculated independently
+     * @returns Total tax amount for all parts
+     */
+    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;
+    }
+    /**
+     * Calculates customer total based on tax calculation type
+     * @param finalTotalsData - Existing totals data
+     * @param LaborTaxAmount - Total labor tax amount
+     * @param PartsTaxAmount - Total parts tax amount
+     * @param LaborList - Array of labor items
+     * @param PartsList - Array of parts
+     * @param IsIndependentTax - Whether tax is calculated independently
+     * @returns Final customer total based on tax type
+     */
+    static GetCustomerTotalBasedOnTaxType(finalTotalsData, LaborTaxAmount, PartsTaxAmount, LaborList, PartsList, IsIndependentTax) {
+        let PartsTotalAfterDisc = this.GetPartsTotalAfterDiscount(PartsList);
+        if (IsIndependentTax) {
+            // Add tax amounts to the total
+            return (0, aggregation_1.addition)(PartsTotalAfterDisc, LaborTaxAmount, PartsTaxAmount);
+        }
+        else {
+            // Subtract discount from the total
+            return (0, aggregation_1.subtraction)(PartsTotalAfterDisc, finalTotalsData.Disc);
+        }
+    }
+    /**
+     * Calculates items total after applying discounts (percentage or fixed)
+     * @param PartsTotalAfterDisc - Parts total after discount
+     * @param PartsTaxAmount - Parts tax amount
+     * @param MainPDisc - Main parts discount amount
+     * @param PDiscInPerc - Parts discount percentage
+     * @returns Final items total after all discounts
+     */
+    static ItemsTotalAfterDiscount(PartsTotalAfterDisc, PartsTaxAmount, MainPDisc, PDiscInPerc) {
+        let ItemsTotal = (0, aggregation_1.addition)(PartsTotalAfterDisc, PartsTaxAmount);
+        // Apply discount if present
+        if (!tr_utils_1.TrUtils.IsZero(MainPDisc)) {
+            if (!tr_utils_1.TrUtils.IsEmpty(PDiscInPerc)) {
+                // Apply percentage discount
+                ItemsTotal = (0, aggregation_1.subtraction)(ItemsTotal, (0, aggregation_1.division)((0, aggregation_1.multiply)(ItemsTotal, Number(PDiscInPerc)), 100));
+            }
+            else {
+                // Apply fixed discount
+                ItemsTotal = (0, aggregation_1.subtraction)(ItemsTotal, MainPDisc);
+            }
+        }
+        return ItemsTotal;
+    }
+    /**
+     * Calculates total CGST tax amount for labor items
+     * @param opCodesList - Array of operation codes/labor
+     * @param IsIndependentTax - Whether tax is calculated independently
+     * @returns Total CGST amount for labor
+     */
+    static GetLaborCGSTTaxTotal(opCodesList, IsIndependentTax) {
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            opCodesList.forEach((Labor) => {
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.CGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+    /**
+     * Calculates total IGST tax amount for labor items
+     * @param opCodesList - Array of operation codes/labor
+     * @param IsIndependentTax - Whether tax is calculated independently
+     * @returns Total IGST amount for labor
+     */
+    static GetLaborIGSTTaxTotal(opCodesList, IsIndependentTax) {
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            opCodesList.forEach((Labor) => {
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.IGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+    /**
+     * Calculates total SGST tax amount for labor items
+     * @param opCodesList - Array of operation codes/labor
+     * @param IsIndependentTax - Whether tax is calculated independently
+     * @returns Total SGST amount for labor
+     */
+    static GetLaborSGSTTaxTotal(opCodesList, IsIndependentTax) {
+        let TotalTaxAmt = 0;
+        if (IsIndependentTax) {
+            opCodesList.forEach((Labor) => {
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Labor.SGST);
+            });
+        }
+        return TotalTaxAmt;
+    }
+    /**
+     * Calculates GST tax breakdown for all parts (CGST, SGST, IGST, Total)
+     * @param PartsList - Array of parts
+     * @param IsIndependentTax - Whether tax is calculated independently
+     * @returns Array containing [CGST, SGST, IGST, Total Tax] amounts
+     */
+    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);
+                TotalIGSTAmt = (0, aggregation_1.addition)(TotalIGSTAmt, Part.IGST);
+                TotalSGSTAmt = (0, aggregation_1.addition)(TotalSGSTAmt, Part.SGST);
+                TotalTaxAmt = (0, aggregation_1.addition)(TotalTaxAmt, Part.CGST, Part.SGST, Part.IGST);
+            });
+        }
+        return [TotalCGSTAmt, TotalSGSTAmt, TotalIGSTAmt, TotalTaxAmt];
+    }
+    /**
+     * Groups parts by HSN code for tax reporting and compliance
+     * @param Parts - Array of parts to group
+     * @param TaxCodes - Available tax codes
+     * @param DecimalsNumber - Number of decimal places
+     * @returns Tax grouping information organized by HSN codes
+     */
+    static GetTaxGroupingForPartsByHSN(Parts, TaxCodes, DecimalsNumber) {
+        // Add combined tax percentage to parts
+        Parts = this.GetCombinedTaxPercentage(Parts, TaxCodes);
+        // Group parts by HSN code
+        let FinalMatchedParts = this.ComparePartsByHSN(Parts, TaxCodes);
+        // Generate HSN-based tax grouping information
+        return this.GetTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes, DecimalsNumber);
+    }
+    /**
+     * Adds combined tax percentage calculation to each part based on tax codes
+     * @param Parts - Array of parts to process
+     * @param TaxCodes - Available tax codes for lookup
+     * @returns Parts array with added tax percentage information
+     */
+    static GetCombinedTaxPercentage(Parts, TaxCodes) {
+        Parts.forEach((Part) => {
+            // Ensure HSN is not null
+            if (tr_utils_1.TrUtils.IsNull(Part.HSN)) {
+                Part.HSN = '';
+            }
+            // Get GST values based on tax code
+            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]);
+            // Calculate combined tax percentage
+            Part.CombinedTaxPercentage = (0, aggregation_1.addition)(Part.CGSTAmt, Part.SGSTAmt, Part.IGSTAmt);
+        });
+        return Parts;
+    }
+    /**
+     * Compares and groups parts by HSN code and tax rates
+     * @param Parts - Array of parts to compare
+     * @param TaxCodes - Available tax codes
+     * @returns Array of parts grouped by HSN code and tax rates
+     */
+    static ComparePartsByHSN(Parts, TaxCodes) {
+        let FinalMatchedParts = [];
+        Parts.forEach((Part) => {
+            // Find parts with same HSN and tax rates that haven't been grouped
+            let MatchedPartsBasedOnHSN = Parts.filter((argPart) => {
+                let PartFound = false;
+                // Check if part is already in a group
+                FinalMatchedParts.forEach((FinalArgParts) => {
+                    let PartIndex = FinalArgParts.findIndex((FinalArgPart) => {
+                        return FinalArgPart._id === argPart._id;
+                    });
+                    if (PartIndex !== -1) {
+                        PartFound = true;
+                    }
+                });
+                // Return parts with same HSN and tax rates that aren't grouped yet
+                return (argPart.HSN === Part.HSN) && (!PartFound) &&
+                    (argPart.CGSTAmt === Part.CGSTAmt) && (argPart.IGSTAmt === Part.IGSTAmt) &&
+                    (argPart.SGSTAmt === Part.SGSTAmt);
+            });
+            // Add group if it contains parts
+            if (MatchedPartsBasedOnHSN.length !== 0) {
+                FinalMatchedParts.push(MatchedPartsBasedOnHSN);
+            }
+        });
+        return FinalMatchedParts;
+    }
+    /**
+     * Generates detailed tax information grouped by HSN codes for compliance reporting
+     * @param FinalMatchedParts - Array of grouped parts by HSN
+     * @param TaxCodes - Available tax codes
+     * @param DecimalsNumber - Number of decimal places for formatting
+     * @returns Array of HSN-wise tax information objects
+     */
+    static GetTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes, DecimalsNumber) {
+        let HSNTaxInfo = [];
+        FinalMatchedParts.forEach((MatchedPart) => {
+            let TaxInfo = {};
+            let TaxOnAmount = 0;
+            let TaxAmount = 0;
+            let CGSTAmt = 0;
+            let SGSTAmt = 0;
+            let IGSTAmt = 0;
+            // Get HSN code and tax percentage from first item
+            let HSN = MatchedPart[0].HSN;
+            TaxInfo.CombinedTaxPercentage = MatchedPart[0].CombinedTaxPercentage;
+            // Calculate totals for all parts in this HSN group
+            MatchedPart.forEach((argMatchedGSTPart) => {
+                TaxOnAmount = (0, aggregation_1.addition)(TaxOnAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.AfterPartDisc, DecimalsNumber));
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.CGST, DecimalsNumber));
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.IGST, DecimalsNumber));
+                TaxAmount = (0, aggregation_1.addition)(TaxAmount, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.SGST, DecimalsNumber));
+                CGSTAmt = (0, aggregation_1.addition)(CGSTAmt, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.CGST, DecimalsNumber));
+                SGSTAmt = (0, aggregation_1.addition)(SGSTAmt, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.SGST, DecimalsNumber));
+                IGSTAmt = (0, aggregation_1.addition)(IGSTAmt, tr_utils_1.TrUtils.FixedTo(argMatchedGSTPart.IGST, DecimalsNumber));
+            });
+            // Build tax information object
+            TaxInfo.HSN = HSN;
+            TaxInfo.CGSTAmt = CGSTAmt;
+            TaxInfo.SGSTAmt = SGSTAmt;
+            TaxInfo.IGSTAmt = IGSTAmt;
+            TaxInfo.TotalTaxableAmount = tr_utils_1.TrUtils.FixPriceValue(TaxOnAmount, DecimalsNumber);
+            TaxInfo.TotalTaxAmount = tr_utils_1.TrUtils.FixPriceValue(TaxAmount, DecimalsNumber);
+            TaxInfo.ItemsCount = MatchedPart.length;
+            TaxInfo.CGST = MatchedPart[0].CGSTAmt;
+            TaxInfo.IGST = MatchedPart[0].IGSTAmt;
+            TaxInfo.SGST = MatchedPart[0].SGSTAmt;
+            // Only add if there's a taxable amount
+            if (TaxOnAmount !== 0) {
+                HSNTaxInfo.push(TaxInfo);
+            }
+        });
+        return HSNTaxInfo;
+    }
+    /**
+     * Retrieves GST values (CGST, SGST, IGST) based on tax code lookup
+     * @param TCode - Tax code identifier
+     * @param TaxCodes - Array of available tax codes
+     * @returns Array containing [CGST, SGST, IGST] values for the tax code
+     */
+    static GetGSTValueBasedOnTaxCode(TCode, TaxCodes) {
+        let CGST = 0;
+        let SGST = 0;
+        let IGST = 0;
+        // Return zeros if tax code is null
+        if (tr_utils_1.TrUtils.IsNull(TCode)) {
+            return [CGST, SGST, IGST];
+        }
+        // Find tax code in the array
+        let TCodeIndex = TaxCodes.findIndex((TaxCode) => {
+            return TaxCode._id === Number(TCode);
+        });
+        // Return appropriate tax values based on tax type
+        if (TCodeIndex !== -1) {
+            if (TaxCodes[TCodeIndex].Type === 'Intra') {
+                // Intra-state: CGST + SGST
+                return [TaxCodes[TCodeIndex].CGST, TaxCodes[TCodeIndex].SGST, 0];
+            }
+            else {
+                // Inter-state: IGST only
+                return [0, 0, TaxCodes[TCodeIndex].IGST];
+            }
+        }
+        else {
+            // Tax code not found, return zeros
+            return [CGST, SGST, IGST];
+        }
+    }
+}
+exports.SalesReceiveTotalsService = SalesReceiveTotalsService;

package/dist/sales-receive/sales-total-calculation.d.ts

@@ -0,0 +1,5 @@
+export declare function SalesTotalCalculations(items?: any[], ops?: any[], isTaxable?: boolean): any;
+/**
+ * Enhanced version with decimal places control
+ */
+export declare function SalesTotalCalculationsWithDecimals(items?: any[], ops?: any[], isTaxable?: boolean, decimalPlaces?: number): any;