foodbot-cart-calculations 1.0.67 → 1.0.68

package/functions/taxCalculation.js

@@ -829,172 +829,202 @@ async function calculateItemWiseSplit(cart, itemWiseItems) {
 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 allItems = options.allItems || cart.items || [];
       const splits = cart.split_payments || [];
 
       // Totals
-      const totalAmount = parseFloat((cart.after_discount) ?? 0) || 0;
-      const totalTax = parseFloat((cart.tax_amount) ?? 0) || 0;
+      const totalAmount = parseFloat(cart.after_discount ?? 0) || 0;
+      const totalTax = parseFloat(cart.tax_amount ?? 0) || 0;
 
-      // Already paid sums
+      // Paid amounts
       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);
+      const paidAmount = paidSplits.reduce((sum, p) => sum + (parseFloat(p.amount || 0)), 0);
+      const paidTax = paidSplits.reduce((sum, p) => sum + (parseFloat(p.tax || 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
+      const unpaidCount = unpaidSplits.length || 1;
 
-      // 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;
+      // per-person distribution
+      let halfSplitTaxPerPerson =
+        typeof options.halfSplitTaxPerPerson == "number"
+          ? options.halfSplitTaxPerPerson
+          : unpaidTotalTax / unpaidCount;
 
-      let halfSplitTotalPerPerson = (typeof options.halfSplitTotalPerPerson == 'number')
-        ? options.halfSplitTotalPerPerson
-        : unpaidTotalAmount / 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;
+          const isLastUnpaid = unpaidIndex === unpaidCount - 1;
 
-          // clone items so we don't mutate shared object
+          // Clone all items for this split user
           p.items = JSON.parse(JSON.stringify(allItems));
 
-          // Recompute item-level tax/amount similar to your itemwise logic
+          // --------------------------------------------------------
+          // 🔥 ADDED LOGIC — Adjust quantities for the LAST UNPAID customer
+          // --------------------------------------------------------
+          if (isLastUnpaid) {
+            p.items.forEach((item) => {
+              const origin = itemWiseItems.find((it) => it._temp_id === item._temp_id);
+              if (!origin) return;
+
+              // 1. Compute how many qty PAID customers already took
+              let paidQty = 0;
+              splits.forEach((sp) => {
+                if (sp.paid_status && sp.items) {
+                  const paidItem = sp.items.find((pi) => pi._temp_id === item._temp_id);
+                  if (paidItem) paidQty += parseFloat(paidItem.quantity || 0);
+                }
+              });
+
+              // 2. Remaining qty for unpaid
+              const remainingQty = origin.quantity - paidQty;
+
+              // 3. Quantity each unpaid gets
+              const qtyPerUnpaid = parseFloat((remainingQty / unpaidCount).toFixed(6));
+
+              // 4. All other unpaid customers qty allocated
+              const allocatedToOthers = qtyPerUnpaid * (unpaidCount - 1);
+
+              // 5. FINAL remainder → assign to *last unpaid customer*
+              const finalQty = parseFloat((remainingQty - allocatedToOthers).toFixed(6));
+
+              item.quantity = finalQty;
+            });
+          }
+
+          // --------------------------------------------------------
+          // RECOMPUTE subtotal + taxes with UPDATED quantities
+          // --------------------------------------------------------
           let subtotal = 0;
           let tax = 0;
 
           for (let pi of p.items) {
-            const item = itemWiseItems.find((i) => i._temp_id == pi._temp_id);
+            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);
+              const unitBase = Number(taxObj.base_price) / (item.quantity || 1);
+              const unitTax = Number(taxObj.tax_amount) / (item.quantity || 1);
+
               return {
                 ...taxObj,
-                base_price: (unitBase * qty).toFixed(6),
-                tax_amount: (unitTaxAmount * qty).toFixed(6),
+                base_price: (unitBase * qty).toFixed(toFix),
+                tax_amount: (unitTax * qty).toFixed(toFix),
               };
             });
 
-            // modifiers
+            // modifiers tax
             let modifierTaxArray = [];
             const mods = item.item_modifiers || item.modifiers || [];
-            for (let m of mods) {
+
+            mods.forEach((m) => {
               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);
+
+              const modTax = m.tax_array.map((tx) => {
+                const unitBase = Number(tx.base_price) / (item.quantity * mq);
+                const unitTax = Number(tx.tax_amount) / (item.quantity * mq);
+
                 return {
                   ...tx,
-                  base_price: (unitBase * (mq * qty)).toFixed(6),
-                  tax_amount: (unitTax * (mq * qty)).toFixed(6),
+                  base_price: (unitBase * (mq * qty)).toFixed(toFix),
+                  tax_amount: (unitTax * (mq * qty)).toFixed(toFix),
                 };
               });
+
               modifierTaxArray.push(...modTax);
-            }
+            });
 
-            // merge item-level taxes by tax_id
+            // Merge item taxes
             const mergedItemTaxMap = {};
-            for (let t of [...quantityWiseTaxArray, ...modifierTaxArray]) {
+            [...quantityWiseTaxArray, ...modifierTaxArray].forEach((t) => {
               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);
-            }
+              mergedItemTaxMap[t.tax_id].base_price += Number(t.base_price);
+              mergedItemTaxMap[t.tax_id].tax_amount += Number(t.tax_amount);
+            });
 
             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),
+              base_price: Number(i.base_price).toFixed(toFix),
+              tax_amount: Number(i.tax_amount).toFixed(toFix),
             }));
 
-            // subtotal and tax contribution for this item in this split
             subtotal += price * qty;
-            tax += (itemTaxTotal / (Number(item.quantity) || 1)) * qty;
-          } // end items loop
+            tax += (itemTaxTotal / item.quantity) * qty;
+          }
 
-          // Merge tax_array across items for this split
+          // Merge taxes for whole split
           const mergedTaxMap = {};
-          for (let pi of p.items) {
+          p.items.forEach((pi) => {
             (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);
+              mergedTaxMap[t.tax_id].base_price += Number(t.base_price);
+              mergedTaxMap[t.tax_id].tax_amount += Number(t.tax_amount);
             });
-          }
+          });
 
           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),
+            base_price: Number(t.base_price).toFixed(toFix),
+            tax_amount: Number(t.tax_amount).toFixed(toFix),
           }));
 
-          // Apply equal split amounts with rounding adjustment:
+          // --------------------------------------------------------
+          // APPLY SPLIT AMOUNT + REMAINDER HANDLING
+          // --------------------------------------------------------
           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(toFix);
-            p.amount = Number(remainingAmount).toFixed(toFix);
+            p.tax = Number(unpaidTotalTax - accumulatedTax).toFixed(toFix);
+            p.amount = Number(unpaidTotalAmount - accumulatedAmount).toFixed(toFix);
             p.due = p.amount;
           } else {
-            // Non-last unpaid: assign precomputed per-person values (rounded to 2 decimals)
-            const taxAmount = Number(Number(halfSplitTaxPerPerson).toFixed(toFix));
-            const dueAmount = Number(Number(halfSplitTotalPerPerson).toFixed(toFix));
+            const taxAmount = Number(halfSplitTaxPerPerson).toFixed(toFix);
+            const amountPer = Number(halfSplitTotalPerPerson).toFixed(toFix);
 
-            p.tax = taxAmount.toFixed(toFix);
-            p.amount = dueAmount.toFixed(toFix);
-            p.due = dueAmount.toFixed(toFix);
+            p.tax = taxAmount;
+            p.amount = amountPer;
+            p.due = amountPer;
 
-            accumulatedTax += taxAmount;
-            accumulatedAmount += dueAmount;
+            accumulatedTax += Number(taxAmount);
+            accumulatedAmount += Number(amountPer);
           }
 
           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;
+        }
       }
+
+      cart.split_payments = splits;
       resolve(cart);
+
     } catch (err) {
-      // bubble up so callers can handle
-      console.error("❌ Split Payment Calculation Failed:", err);
+      console.error("❌ HalfSplit Calculation Error:", err);
       resolve({
-        'status': 'error',
-        'status_code': 500,
-        'message': 'Internal server error',
-        'error': error.stack,
+        status: "error",
+        status_code: 500,
+        message: "Internal server error",
+        error: err.stack,
       });
     }
   });
 }
 
+
 module.exports = { calculateTax2, calculateItemWiseSplit, calculateHalfSplit }

package/package.json

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