shareneus 1.7.4 → 1.7.6

package/src/transaction-calculations/total-calculation.ts

@@ -0,0 +1,443 @@
+import { Add, Divide, Multiply, Subtract } from "../shared/math-operations";
+import { GetNumber } from "../shared/util";
+
+/**
+ * Safely handles null/undefined arrays and returns empty array
+ */
+function safeArray(arr: any[]): any[] {
+    return Array.isArray(arr) ? arr : [];
+}
+
+function getLineNetAmount(line: any): number {
+    return Subtract(GetNumber(line.UnAmt || line.Amt), Add(GetNumber(line.Disc), GetNumber(line.RecDisc)));
+}
+
+function getTaxCodeById(taxCodes: any[], taxCodeId: any) {
+    const normalizedTaxCodeId = Number(taxCodeId);
+    if (!normalizedTaxCodeId) {
+        return null;
+    }
+
+    return taxCodes.find((taxCode: any) => Number(taxCode._id) === normalizedTaxCodeId) || null;
+}
+
+function getTaxComponentRate(taxCode: any, code: string): number {
+    const component = safeArray(taxCode?.Components).find((item: any) => item?.Code === code);
+    if (component) {
+        return GetNumber(component.Rate);
+    }
+
+    return GetNumber(taxCode?.[code]);
+}
+
+function buildTaxesFromFlatFields(line: any, taxCode: any, netAmount: number): any[] {
+    const flatTaxes = [
+        { Code: "CGST", Amt: GetNumber(line.CGST) },
+        { Code: "SGST", Amt: GetNumber(line.SGST) },
+        { Code: "IGST", Amt: GetNumber(line.IGST) }
+    ];
+
+    return flatTaxes
+        .filter((tax) => tax.Amt > 0)
+        .map((tax) => ({
+            Code: tax.Code,
+            Amt: tax.Amt,
+            Rate: getTaxComponentRate(taxCode, tax.Code) || (netAmount > 0 ? Multiply(Divide(tax.Amt, netAmount), 100) : 0),
+            TaxCodeId: GetNumber(line.TCode) || GetNumber(taxCode?._id)
+        }));
+}
+
+function buildTaxesFromTaxCode(line: any, taxCode: any, netAmount: number): any[] {
+    if (!taxCode) {
+        return [];
+    }
+
+    const taxComponents = safeArray(taxCode.Components);
+    if (taxComponents.length > 0) {
+        return taxComponents
+            .filter((component: any) => ["CGST", "SGST", "IGST"].includes(component?.Code))
+            .map((component: any) => ({
+                Code: component.Code,
+                Amt: Multiply(netAmount, Divide(GetNumber(component.Rate), 100)),
+                Rate: GetNumber(component.Rate),
+                TaxCodeId: GetNumber(taxCode._id)
+            }))
+            .filter((tax: any) => tax.Amt > 0);
+    }
+
+    const legacyTaxes = [
+        { Code: "CGST", Rate: GetNumber(taxCode.CGST) },
+        { Code: "SGST", Rate: GetNumber(taxCode.SGST) },
+        { Code: "IGST", Rate: GetNumber(taxCode.IGST) }
+    ];
+
+    return legacyTaxes
+        .filter((tax) => tax.Rate > 0)
+        .map((tax) => ({
+            Code: tax.Code,
+            Amt: Multiply(netAmount, Divide(tax.Rate, 100)),
+            Rate: tax.Rate,
+            TaxCodeId: GetNumber(taxCode._id)
+        }));
+}
+
+function getResolvedTaxes(line: any, taxCodes: any[] = []): any[] {
+    const lineTaxes = safeArray(line?.Taxes);
+    if (lineTaxes.length > 0) {
+        return lineTaxes.map((tax: any) => ({
+            ...tax,
+            Code: tax?.Code,
+            Amt: GetNumber(tax?.Amt),
+            Rate: GetNumber(tax?.Rate),
+            TaxCodeId: GetNumber(tax?.TaxCodeId)
+        })).filter((tax: any) => !!tax.Code);
+    }
+
+    const netAmount = getLineNetAmount(line);
+    const taxCode = getTaxCodeById(taxCodes, line?.TCode);
+
+    const taxesFromFlatFields = buildTaxesFromFlatFields(line, taxCode, netAmount);
+    if (taxesFromFlatFields.length > 0) {
+        return taxesFromFlatFields;
+    }
+
+    return buildTaxesFromTaxCode(line, taxCode, netAmount);
+}
+
+function getTaxAmountByCode(taxes: any[], code: string): number {
+    return taxes
+        .filter((tax: any) => tax.Code === code)
+        .reduce((sum: number, tax: any) => Add(sum, GetNumber(tax.Amt)), 0);
+}
+
+export function TotalCalculations(items: any[] = [], ops: any[] = [], isTaxable: boolean = false, taxCodes: any[] = [], Adjust: number = 0) {
+    // Handle null/undefined arrays
+    const safeItems = safeArray(items);
+    const safeOps = safeArray(ops);
+    const safeTaxCodes = safeArray(taxCodes);
+
+    // Initialize all totals
+    let subtotalOnItems: number = 0;
+    let totalTaxOnItems: number = 0;
+    let totalDiscountOnItems: number = 0;
+
+    let subtotalOnLabor: number = 0;
+    let totalTaxOnLabor: number = 0;
+    let totalDiscountOnLabor: number = 0;
+
+    let total: number = 0;
+    let subtotal: number = 0;
+    let totalTax: number = 0;
+    let totalDiscount: number = 0;
+    let roundOff: number = 0;
+    let totalAfterRounded: number = 0;
+
+    // Returns totals
+    let returnSubtotal: number = 0;
+    let nonReturnSubTotal: number = 0;
+    let returnTax: number = 0;
+    let nonReturnTax: number = 0;
+    let returnTotal: number = 0;
+    let nonReturnTotal: number = 0;
+    let returnTotalDiscount: number = 0;
+    let nonReturnTotalDiscount: number = 0;
+
+    // Tax breakdown totals - only calculate if taxable
+    let totalSGST: number = 0;
+    let totalCGST: number = 0;
+    let totalIGST: number = 0;
+
+    let totalSGSTOnItems: number = 0;
+    let totalCGSTOnItems: number = 0;
+    let totalIGSTOnItems: number = 0;
+
+    let totalSGSTOnLabor: number = 0;
+    let totalCGSTOnLabor: number = 0;
+    let totalIGSTOnLabor: number = 0;
+
+
+    // Calculate items totals with null safety
+    safeItems.forEach((item: any) => {
+        const itemDisc = GetNumber(item.Disc);
+        const itemRecDisc = GetNumber(item.RecDisc);
+        const itemUnAmt = GetNumber(item.UnAmt);
+
+        // Calculate return total for items with Ret = true (explicitly check for true)
+        if (item.Ret === true) {
+            const itemNetAmount = Subtract(itemUnAmt, Add(itemDisc, itemRecDisc));
+
+            returnTotalDiscount = Add(returnTotalDiscount, itemDisc, itemRecDisc);
+            // Add to return subtotal (net amount after discounts)
+            returnSubtotal = Add(returnSubtotal, itemUnAmt);
+
+            if (isTaxable) {
+                const resolvedItemTaxes = getResolvedTaxes(item, safeTaxCodes);
+                const itemSGST = getTaxAmountByCode(resolvedItemTaxes, "SGST");
+                const itemCGST = getTaxAmountByCode(resolvedItemTaxes, "CGST");
+                const itemIGST = getTaxAmountByCode(resolvedItemTaxes, "IGST");
+                const itemTotalTax = Add(itemSGST, itemCGST, itemIGST);
+
+                // Add to return tax
+                returnTax = Add(returnTax, itemTotalTax);
+
+                // Return total includes net amount + tax
+                returnTotal = Add(returnTotal, itemNetAmount, itemTotalTax);
+            } else {
+                // Return total without tax (same as returnSubtotal when not taxable)
+                returnTotal = Add(returnTotal, itemNetAmount);
+            }
+        } else {
+            // Process normal items (Ret is false, undefined, or null - all treated as normal items)
+            totalDiscountOnItems = Add(totalDiscountOnItems, itemDisc, itemRecDisc);
+            subtotalOnItems = Add(subtotalOnItems, itemUnAmt);
+
+            // Only calculate tax if taxable
+            if (isTaxable) {
+                const resolvedItemTaxes = getResolvedTaxes(item, safeTaxCodes);
+                const itemSGST = getTaxAmountByCode(resolvedItemTaxes, "SGST");
+                const itemCGST = getTaxAmountByCode(resolvedItemTaxes, "CGST");
+                const itemIGST = getTaxAmountByCode(resolvedItemTaxes, "IGST");
+
+                // Add individual tax amounts for items
+                totalSGSTOnItems = Add(totalSGSTOnItems, itemSGST);
+                totalCGSTOnItems = Add(totalCGSTOnItems, itemCGST);
+                totalIGSTOnItems = Add(totalIGSTOnItems, itemIGST);
+
+                totalTaxOnItems = Add(totalTaxOnItems, itemSGST, itemCGST, itemIGST);
+            }
+        }
+    });
+
+    // Calculate operations/labor totals with null safety
+    safeOps.forEach((op: any) => {
+        const opDisc = GetNumber(op.Disc);
+        const opRecDisc = GetNumber(op.RecDisc);
+        const opAmt = GetNumber(op.Amt);
+
+        totalDiscountOnLabor = Add(totalDiscountOnLabor, opDisc, opRecDisc);
+        subtotalOnLabor = Add(subtotalOnLabor, opAmt);
+
+        // Only calculate tax if taxable
+        if (isTaxable) {
+            const resolvedOpTaxes = getResolvedTaxes(op, safeTaxCodes);
+            const opSGST = getTaxAmountByCode(resolvedOpTaxes, "SGST");
+            const opCGST = getTaxAmountByCode(resolvedOpTaxes, "CGST");
+            const opIGST = getTaxAmountByCode(resolvedOpTaxes, "IGST");
+
+            // Add individual tax amounts for operations/labor
+            totalSGSTOnLabor = Add(totalSGSTOnLabor, opSGST);
+            totalCGSTOnLabor = Add(totalCGSTOnLabor, opCGST);
+            totalIGSTOnLabor = Add(totalIGSTOnLabor, opIGST);
+
+            totalTaxOnLabor = Add(totalTaxOnLabor, opSGST, opCGST, opIGST);
+        }
+    });
+
+    // Calculate combined totals
+    totalDiscount = Add(totalDiscountOnItems, totalDiscountOnLabor);
+    totalTax = Add(totalTaxOnItems, totalTaxOnLabor);
+    subtotal = Add(subtotalOnItems, subtotalOnLabor);
+    nonReturnSubTotal = subtotal;
+    nonReturnTax = totalTax;
+    nonReturnTotalDiscount = totalDiscount;
+
+    // Step 2: Add tax if taxable
+    nonReturnTotal = isTaxable ? Add(Subtract(subtotal, totalDiscount), totalTax) : Subtract(subtotal, totalDiscount);
+
+    // Subtract return subtotal from subtotal
+    subtotal = Subtract(subtotal, returnSubtotal);
+
+    // Subtract return tax from total tax
+    totalTax = Subtract(totalTax, returnTax);
+
+    // Subtract return Discount from total discount
+    totalDiscount = Subtract(totalDiscount, returnTotalDiscount);
+
+    // Calculate combined tax breakdown totals only if taxable
+    if (isTaxable) {
+        totalSGST = Add(totalSGSTOnItems, totalSGSTOnLabor);
+        totalCGST = Add(totalCGSTOnItems, totalCGSTOnLabor);
+        totalIGST = Add(totalIGSTOnItems, totalIGSTOnLabor);
+    }
+
+    // FIXED CALCULATION: Correct order of operations
+    // Step 1: Calculate net amount after discount
+    const netAmountAfterDiscount = Subtract(subtotal, totalDiscount);
+
+    // Step 2: Add tax if taxable
+    total = isTaxable ? Add(netAmountAfterDiscount, totalTax) : netAmountAfterDiscount;
+
+    // Step 3: Add adjustments
+    total = Add(total, GetNumber(Adjust));
+
+    // // Step 4: Subtract return total from the final total
+    // total = Subtract(total, returnTotal);
+
+    // FIXED ROUNDING: Use Math.round instead of Math.floor
+    const roundedTotal = Math.round(total);
+    roundOff = Subtract(roundedTotal, total);
+
+    // Update total to rounded value
+    totalAfterRounded = roundedTotal;
+
+    // Base return object
+    const result: any = {
+        total,
+        totalAfterRounded,
+        subtotal,
+        totalDiscount,
+        roundOff,
+        subtotalOnItems,
+        subtotalOnLabor,
+        totalDiscountOnItems,
+        totalDiscountOnLabor,
+        netAmountAfterDiscount,
+        returnSubtotal,
+        returnTax,
+        returnTotal,
+        returnTotalDiscount,
+        nonReturnSubTotal,
+        nonReturnTax,
+        nonReturnTotal,
+        nonReturnTotalDiscount
+    };
+
+    // Only include tax fields and taxSummary if taxable
+    if (isTaxable) {
+        result.totalTax = totalTax;
+        result.totalTaxOnItems = totalTaxOnItems;
+        result.totalTaxOnLabor = totalTaxOnLabor;
+        result.totalSGST = totalSGST;
+        result.totalCGST = totalCGST;
+        result.totalIGST = totalIGST;
+        result.totalSGSTOnItems = totalSGSTOnItems;
+        result.totalCGSTOnItems = totalCGSTOnItems;
+        result.totalIGSTOnItems = totalIGSTOnItems;
+        result.totalSGSTOnLabor = totalSGSTOnLabor;
+        result.totalCGSTOnLabor = totalCGSTOnLabor;
+        result.totalIGSTOnLabor = totalIGSTOnLabor;
+
+        // Calculate tax summary for both new Taxes[] and legacy tax-code based records
+        // Filter out items where Ret is true (only include non-return items)
+        const nonReturnItems = safeItems.filter((item: any) => item.Ret !== true);
+        result.itemsTaxSummary = CalculateTaxSummary(nonReturnItems, safeTaxCodes);
+        result.opsTaxSummary = CalculateTaxSummary(safeOps, safeTaxCodes);
+    }
+
+    return result;
+}
+
+/**
+ * Enhanced version with decimal places control
+ */
+export function TotalCalculationsWithDecimals(
+    items: any[] = [],
+    ops: any[] = [],
+    isTaxable: boolean = false,
+    taxCodes: any[] = [],
+    Adjust: number,
+    decimalPlaces: number = 2,
+) {
+    const result = TotalCalculations(items, ops, isTaxable, taxCodes, Adjust);
+
+    // Round all values to specified decimal places
+    const roundToDecimals = (num: number) => Math.round(num * Math.pow(10, decimalPlaces)) / Math.pow(10, decimalPlaces);
+
+    // Base rounded result
+    const roundedResult: any = {
+        total: roundToDecimals(result.total),
+        totalAfterRounded: roundToDecimals(result.totalAfterRounded),
+        subtotal: roundToDecimals(result.subtotal),
+        totalDiscount: roundToDecimals(result.totalDiscount),
+        roundOff: roundToDecimals(result.roundOff),
+        subtotalOnItems: roundToDecimals(result.subtotalOnItems),
+        subtotalOnLabor: roundToDecimals(result.subtotalOnLabor),
+        totalDiscountOnItems: roundToDecimals(result.totalDiscountOnItems),
+        totalDiscountOnLabor: roundToDecimals(result.totalDiscountOnLabor),
+        // returned related fields
+        netAmountAfterDiscount: roundToDecimals(result.netAmountAfterDiscount),
+        returnSubtotal: roundToDecimals(result.returnSubtotal),
+        returnTax: roundToDecimals(result.returnTax),
+        returnTotal: roundToDecimals(result.returnTotal),
+        returnTotalDiscount: roundToDecimals(result.returnTotalDiscount),
+        nonReturnSubTotal: roundToDecimals(result.nonReturnSubTotal),
+        nonReturnTax: roundToDecimals(result.nonReturnTax),
+        nonReturnTotal: roundToDecimals(result.nonReturnTotal),
+        nonReturnTotalDiscount: roundToDecimals(result.nonReturnTotalDiscount)
+    };
+
+    // Only include tax fields and taxSummary if taxable
+    if (isTaxable) {
+        roundedResult.totalTax = roundToDecimals(result.totalTax);
+        roundedResult.totalTaxOnItems = roundToDecimals(result.totalTaxOnItems);
+        roundedResult.totalTaxOnLabor = roundToDecimals(result.totalTaxOnLabor);
+        roundedResult.totalSGST = roundToDecimals(result.totalSGST);
+        roundedResult.totalCGST = roundToDecimals(result.totalCGST);
+        roundedResult.totalIGST = roundToDecimals(result.totalIGST);
+        roundedResult.totalSGSTOnItems = roundToDecimals(result.totalSGSTOnItems);
+        roundedResult.totalCGSTOnItems = roundToDecimals(result.totalCGSTOnItems);
+        roundedResult.totalIGSTOnItems = roundToDecimals(result.totalIGSTOnItems);
+        roundedResult.totalSGSTOnLabor = roundToDecimals(result.totalSGSTOnLabor);
+        roundedResult.totalCGSTOnLabor = roundToDecimals(result.totalCGSTOnLabor);
+        roundedResult.totalIGSTOnLabor = roundToDecimals(result.totalIGSTOnLabor);
+
+        // Round tax summary only if it exists
+        if (result.itemsTaxSummary) {
+            roundedResult.itemsTaxSummary = result.itemsTaxSummary.map((tax: any) => ({
+                ...tax,
+                TaxableAmount: roundToDecimals(tax.TaxableAmount),
+                TaxAmount: roundToDecimals(tax.TaxAmount),
+                CGSTAmount: roundToDecimals(tax.CGSTAmount),
+                SGSTAmount: roundToDecimals(tax.SGSTAmount),
+                IGSTAmount: roundToDecimals(tax.IGSTAmount)
+            }));
+        }
+        if (result.opsTaxSummary) {
+            roundedResult.opsTaxSummary = result.opsTaxSummary.map((tax: any) => ({
+                ...tax,
+                TaxableAmount: roundToDecimals(tax.TaxableAmount),
+                TaxAmount: roundToDecimals(tax.TaxAmount),
+                CGSTAmount: roundToDecimals(tax.CGSTAmount),
+                SGSTAmount: roundToDecimals(tax.SGSTAmount),
+                IGSTAmount: roundToDecimals(tax.IGSTAmount)
+            }));
+        }
+    }
+
+    return roundedResult;
+}
+
+export function CalculateTaxSummary(items: any[], taxCodes: any[]) {
+    return Object.values(
+        items.reduce((acc: any, item: any) => {
+            const taxes = getResolvedTaxes(item, taxCodes);
+            if (taxes.length === 0) return acc;
+
+            const percent = (taxes.reduce((sum: number, tax: any) => Add(sum, GetNumber(tax.Rate)), 0) + "%");
+            const taxable = getLineNetAmount(item);
+            const cgstAmount = getTaxAmountByCode(taxes, "CGST");
+            const sgstAmount = getTaxAmountByCode(taxes, "SGST");
+            const igstAmount = getTaxAmountByCode(taxes, "IGST");
+            const totalTaxAmount = Add(cgstAmount, sgstAmount, igstAmount);
+
+            if (!acc[percent]) {
+                acc[percent] = {
+                    Tax: percent,
+                    TaxableAmount: 0,
+                    TaxAmount: 0,
+                    CGSTAmount: 0,
+                    SGSTAmount: 0,
+                    IGSTAmount: 0
+                };
+            }
+
+            acc[percent].TaxableAmount = Add(acc[percent].TaxableAmount, taxable);
+            acc[percent].TaxAmount = Add(acc[percent].TaxAmount, totalTaxAmount);
+            acc[percent].CGSTAmount = Add(acc[percent].CGSTAmount, cgstAmount);
+            acc[percent].SGSTAmount = Add(acc[percent].SGSTAmount, sgstAmount);
+            acc[percent].IGSTAmount = Add(acc[percent].IGSTAmount, igstAmount);
+
+            return acc;
+        }, {})
+    );
+}