foodbot-cart-calculations 1.0.62 → 1.0.64

package/functions/taxCalculation.js

@@ -84,9 +84,9 @@ function calculateTax2(cart, texSettings, taxType) {
             }, 300)
           });
 
-          calculateItemWiseSplit(cart).then((cart) => {
+          // calculateItemWiseSplit(cart).then((cart) => {
             resolve(cart);
-          });
+          // });
         }
       });
     } catch (error) {
@@ -806,4 +806,192 @@ async function calculateItemWiseSplit(cart, itemWiseItems) {
   });
 }
 
-module.exports = { calculateTax2, calculateItemWiseSplit }
+// calculateHalfSplit.js
+/**
+ * Calculate half-split (or N-equal split for unpaid customers) with rounding adjustments.
+ *
+ * Parameters:
+ *  - cart: object containing order, split_payments etc. (mutated and returned)
+ *  - selectedMembers: (not used directly in calculation here, kept for parity with caller)
+ *  - options: optional object {
+ *      itemWiseItems,    // array used to derive per-item tax/prices (falls back to cart.itemWiseItems)
+ *      allItems,         // template items for each split (falls back to cart.order.items or cart.items)
+ *      halfSplitTaxPerPerson,    // optional precomputed per-person tax (Number)
+ *      halfSplitTotalPerPerson   // optional precomputed per-person amount (Number)
+ *    }
+ *
+ * Returns:
+ *  - resolved Promise with updated cart
+ */
+async function calculateHalfSplit(cart, options = {}) {
+  return new Promise(async (resolve, reject) => {
+    try {
+      // Safe getters / defaults
+      const itemWiseItems = options.itemWiseItems || [];
+      const allItems = options.allItems || (cart && cart.items) || [];
+      const splits = cart.split_payments || [];
+
+      // Totals
+      const totalAmount = parseFloat((cart.after_discount) ?? 0) || 0;
+      const totalTax = parseFloat((cart.tax_amount) ?? 0) || 0;
+
+      // Already paid sums
+      const paidSplits = splits.filter((p) => p.paid_status);
+      const paidAmount = paidSplits.reduce((sum, p) => sum + (parseFloat(p.amount || '0') || 0), 0);
+      const paidTax = paidSplits.reduce((sum, p) => sum + (parseFloat(p.tax || '0') || 0), 0);
+
+      // Unpaid totals
+      const unpaidTotalAmount = totalAmount - paidAmount;
+      const unpaidTotalTax = totalTax - paidTax;
+
+      // Unpaid split count
+      const unpaidSplits = splits.filter((p) => !p.paid_status);
+      const unpaidCount = unpaidSplits.length || 1; // avoid division by zero
+
+      // If caller provided per-person values use them, otherwise compute equal split per unpaid person
+      let halfSplitTaxPerPerson = (typeof options.halfSplitTaxPerPerson == 'number')
+        ? options.halfSplitTaxPerPerson
+        : unpaidTotalTax / unpaidCount;
+
+      let halfSplitTotalPerPerson = (typeof options.halfSplitTotalPerPerson == 'number')
+        ? options.halfSplitTotalPerPerson
+        : unpaidTotalAmount / unpaidCount;
+
+      // Keep accumulators for rounding remainder
+      let accumulatedAmount = 0;
+      let accumulatedTax = 0;
+      let unpaidIndex = 0;
+
+      // For each split payment: assign items, compute item-level taxes & subtotal, then apply split rounding rules
+      for (let p of splits) {
+        if (!p.paid_status) {
+          const isLastUnpaid = unpaidIndex == unpaidCount - 1;
+
+          // clone items so we don't mutate shared object
+          p.items = JSON.parse(JSON.stringify(allItems));
+
+          // Recompute item-level tax/amount similar to your itemwise logic
+          let subtotal = 0;
+          let tax = 0;
+
+          for (let pi of p.items) {
+            const item = itemWiseItems.find((i) => i._temp_id == pi._temp_id);
+            if (!item) continue;
+
+            const qty = Number(pi.quantity || 0);
+            const price = Number(item.per_item_cost || 0);
+            const itemTaxTotal = Number(item.total_tax_amount || 0);
+
+            // quantity-wise tax array
+            const quantityWiseTaxArray = (item.tax_array || []).map((taxObj) => {
+              const unitBase = Number(taxObj.base_price || 0) / (Number(item.quantity) || 1);
+              const unitTaxAmount = Number(taxObj.tax_amount || 0) / (Number(item.quantity) || 1);
+              return {
+                ...taxObj,
+                base_price: (unitBase * qty).toFixed(6),
+                tax_amount: (unitTaxAmount * qty).toFixed(6),
+              };
+            });
+
+            // modifiers
+            let modifierTaxArray = [];
+            const mods = item.item_modifiers || item.modifiers || [];
+            for (let m of mods) {
+              const mq = Number(m.quantity || 0) || 1;
+              const modTax = (m.tax_array || []).map((tx) => {
+                const unitBase = Number(tx.base_price || 0) / ((Number(item.quantity) || 1) * mq);
+                const unitTax = Number(tx.tax_amount || 0) / ((Number(item.quantity) || 1) * mq);
+                return {
+                  ...tx,
+                  base_price: (unitBase * (mq * qty)).toFixed(6),
+                  tax_amount: (unitTax * (mq * qty)).toFixed(6),
+                };
+              });
+              modifierTaxArray.push(...modTax);
+            }
+
+            // merge item-level taxes by tax_id
+            const mergedItemTaxMap = {};
+            for (let t of [...quantityWiseTaxArray, ...modifierTaxArray]) {
+              if (!mergedItemTaxMap[t.tax_id]) {
+                mergedItemTaxMap[t.tax_id] = { ...t, base_price: 0, tax_amount: 0 };
+              }
+              mergedItemTaxMap[t.tax_id].base_price += Number(t.base_price || 0);
+              mergedItemTaxMap[t.tax_id].tax_amount += Number(t.tax_amount || 0);
+            }
+
+            pi.tax_array = Object.values(mergedItemTaxMap).map((i) => ({
+              ...i,
+              base_price: Number(i.base_price).toFixed(6),
+              tax_amount: Number(i.tax_amount).toFixed(6),
+            }));
+
+            // subtotal and tax contribution for this item in this split
+            subtotal += price * qty;
+            tax += (itemTaxTotal / (Number(item.quantity) || 1)) * qty;
+          } // end items loop
+
+          // Merge tax_array across items for this split
+          const mergedTaxMap = {};
+          for (let pi of p.items) {
+            (pi.tax_array || []).forEach((t) => {
+              if (!mergedTaxMap[t.tax_id]) {
+                mergedTaxMap[t.tax_id] = { ...t, base_price: 0, tax_amount: 0 };
+              }
+              mergedTaxMap[t.tax_id].base_price += Number(t.base_price || 0);
+              mergedTaxMap[t.tax_id].tax_amount += Number(t.tax_amount || 0);
+            });
+          }
+
+          p.merge_tax_array = Object.values(mergedTaxMap).map((t) => ({
+            ...t,
+            base_price: Number(t.base_price).toFixed(6),
+            tax_amount: Number(t.tax_amount).toFixed(6),
+          }));
+
+          // Apply equal split amounts with rounding adjustment:
+          if (isLastUnpaid) {
+            // last unpaid gets the remainder (unpaid totals minus accumulated assigned amounts)
+            // Use arithmetic with Number() and then format to 2 decimals for amount/tax
+            const remainingTax = (unpaidTotalTax - accumulatedTax);
+            const remainingAmount = (unpaidTotalAmount - accumulatedAmount);
+
+            p.tax = Number(remainingTax).toFixed(2);
+            p.amount = Number(remainingAmount).toFixed(2);
+            p.due = p.amount;
+          } else {
+            // Non-last unpaid: assign precomputed per-person values (rounded to 2 decimals)
+            const taxAmount = Number(Number(halfSplitTaxPerPerson).toFixed(2));
+            const dueAmount = Number(Number(halfSplitTotalPerPerson).toFixed(2));
+
+            p.tax = taxAmount.toFixed(2);
+            p.amount = dueAmount.toFixed(2);
+            p.due = dueAmount.toFixed(2);
+
+            accumulatedTax += taxAmount;
+            accumulatedAmount += dueAmount;
+          }
+
+          unpaidIndex++;
+        } // end if unpaid
+      } // end for splits loop
+
+      // Attach updated splits back to cart (if different structure)
+      if (cart.split_payments) {
+        cart.split_payments = splits;
+      }
+      resolve(cart);
+    } catch (err) {
+      // bubble up so callers can handle
+      console.error("❌ Split Payment Calculation Failed:", err);
+      resolve({
+        'status': 'error',
+        'status_code': 500,
+        'message': 'Internal server error',
+        'error': error.stack,
+      });
+    }
+  });
+}
+
+module.exports = { calculateTax2, calculateItemWiseSplit, calculateHalfSplit }

package/index.js

@@ -1,5 +1,5 @@
 const calculation = require('./calculations');
-const { calculateItemWiseSplit } = require('./functions/taxCalculation');
+const { calculateItemWiseSplit, calculateHalfSplit } = require('./functions/taxCalculation');
 // const fs = require('fs');
 // const path = require('path')
 
@@ -76,7 +76,7 @@ async function calculateTax(inputJSON) {
   })
 }
 
-// let json = JSON.parse(fs.readFileSync('./sample.json', 'utf8'));
+let json = JSON.parse(fs.readFileSync('./sample.json', 'utf8'));
 
 // calculateTax(json).then(res=>{
 //   // console.log(JSON.stringify(res))
@@ -114,4 +114,4 @@ async function calculateTax(inputJSON) {
 //   console.log(err)
 // })
  
-module.exports = { calculateTax , calculateItemWiseSplit}
+module.exports = { calculateTax , calculateItemWiseSplit, calculateHalfSplit}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foodbot-cart-calculations",
-  "version": "1.0.62",
+  "version": "1.0.64",
   "description": "Package for cart calculations in which it performs discount distribution and tax distribution on order",
   "main": "index.js",
   "scripts": {