foodbot-cart-calculations 1.0.66 → 1.0.68

package/calculations.js

@@ -61,7 +61,7 @@ function applyDistribution(body) {
                             // let message = i18n.__("kiosk_point_message_redeemed").replace(/{totalAmount}/g, currency + "" + totalStoreValue).replace(/{paidPoints}/g, currency + "" + final.store_value)
                             // final.points_redeem_message = message
                         }
-                        taxCalculation.calculateTax2(final, taxSettings, taxType).then(taxData => {
+                        taxCalculation.calculateTax2(final, taxSettings, taxType, body.isSplit).then(taxData => {
                             taxData.sub_total = taxData.cartTotal;
                             mainCart.final_amount = parseFloat(taxData.cartTotal);
                             mainCart.cash_expected = parseFloat(taxData.cartTotal) ;

package/functions/taxCalculation.js

@@ -1,6 +1,8 @@
-function calculateTax2(cart, texSettings, taxType) {
+var toFix = 2;
+function calculateTax2(cart, texSettings, taxType, isSplit = false) {
   return new Promise(function (resolve, reject) {
     try {
+      toFix = isSplit ? 6 : 2;
       cart.cartTotal = 0;
       cart.tax_amount = 0;
       cart.item_details.forEach(function (v) {
@@ -44,15 +46,15 @@ function calculateTax2(cart, texSettings, taxType) {
         }
         promoDiscount = (promoDiscount > element.item_price * element.quantity) ? element.item_price * element.quantity : promoDiscount;
         element.promotion_discount = JSON.parse(JSON.stringify(promoDiscount));
-        promoDiscount = parseFloat(promoDiscount).toFixed(6);
+        promoDiscount = parseFloat(promoDiscount).toFixed(toFix);
 
         let afterDiscount = element.item_price * element.quantity - promoDiscount;
-        afterDiscount = parseFloat(afterDiscount).toFixed(6);
+        afterDiscount = parseFloat(afterDiscount).toFixed(toFix);
         afterDiscount = afterDiscount - pointsDiscount;
-        afterDiscount = parseFloat(afterDiscount).toFixed(6);
+        afterDiscount = parseFloat(afterDiscount).toFixed(toFix);
         afterDiscount = (afterDiscount < 0) ? 0 : afterDiscount;
         cart.cartTotal = parseFloat(cart.cartTotal) + parseFloat(afterDiscount);
-        cart.cartTotal = parseFloat(cart.cartTotal).toFixed(6);
+        cart.cartTotal = parseFloat(cart.cartTotal).toFixed(toFix);
         total = +element.item_price;
         if (element.isPackage == 1) {
           let result = await calculatePackageItemTax(cart, itemIndex, element, texSettings, afterDiscount, taxType);
@@ -75,7 +77,7 @@ function calculateTax2(cart, texSettings, taxType) {
         }
         if (itemIndex == cart.item_details.length - 1) {
           cart.cart_total_with_tax = parseFloat(cart.cartTotal) + parseFloat(cart.tax_amount);
-          cart.cart_total_with_tax = parseFloat(cart.cart_total_with_tax).toFixed(6);
+          cart.cart_total_with_tax = parseFloat(cart.cart_total_with_tax).toFixed(toFix);
 
           //delay
           await new Promise((resolve) => {
@@ -113,6 +115,7 @@ function calculateItemTax(cart, itemIndex, element, tax_settings, afterDicsount,
         let iepsTaxRateQuantity = +resp.iepsTaxRateQuantity;
         let itemTotalTax = 0;
         let tax_array = []
+        console.log("isSplit", toFix)
         if (itemTaxs && itemTaxs.length > 0) {
           itemTaxs.forEach(async (itemTaxArray, itemTaxIndex) => {
             // let startItemTax = JSON.parse(JSON.stringify(itemTaxArray))
@@ -125,13 +128,13 @@ function calculateItemTax(cart, itemIndex, element, tax_settings, afterDicsount,
             // } else {
             //   taxAmount = (lastPrice * startItemTax.tax_rate) / 100;
             // }
-            // taxAmount = parseFloat(taxAmount).toFixed(6)
-            // itemTotalTax = (parseFloat(itemTotalTax) + parseFloat(taxAmount)).toFixed(6)
+            // taxAmount = parseFloat(taxAmount).toFixed(toFix)
+            // itemTotalTax = (parseFloat(itemTotalTax) + parseFloat(taxAmount)).toFixed(toFix)
 
             // cart.tax_amount = parseFloat(cart.tax_amount) + parseFloat(taxAmount)
-            // cart.tax_amount = parseFloat(cart.tax_amount).toFixed(6)
-            // startItemTax.base_price = parseFloat(lastPrice).toFixed(6)
-            // startItemTax.tax_amount = parseFloat(taxAmount).toFixed(6)
+            // cart.tax_amount = parseFloat(cart.tax_amount).toFixed(toFix)
+            // startItemTax.base_price = parseFloat(lastPrice).toFixed(toFix)
+            // startItemTax.tax_amount = parseFloat(taxAmount).toFixed(toFix)
             // element.tax_array.push(JSON.parse(JSON.stringify(startItemTax)))
 
 
@@ -186,13 +189,13 @@ function calculatePackageItemTax(cart, itemIndex, element, tax_settings, afterDi
       let defaultComboDiscount = packageItem.default_combo_discount ? packageItem.default_combo_discount : 0
       let afterDicsountPackage = packageItem.price * packageItem.quantity - promoDiscountPackage
 
-      afterDicsountPackage = parseFloat(afterDicsountPackage).toFixed(6)
+      afterDicsountPackage = parseFloat(afterDicsountPackage).toFixed(toFix)
       afterDicsountPackage = afterDicsountPackage - pointsDisouuntPackage
 
-      afterDicsountPackage = parseFloat(afterDicsountPackage).toFixed(6)
+      afterDicsountPackage = parseFloat(afterDicsountPackage).toFixed(toFix)
       afterDicsountPackage = afterDicsountPackage - defaultComboDiscount
 
-      afterDicsountPackage = parseFloat(afterDicsountPackage).toFixed(6)
+      afterDicsountPackage = parseFloat(afterDicsountPackage).toFixed(toFix)
 
       getTaxSettings2(packageItem.tax_id, tax_settings, packageItem.ieps_tax).then(async (itemTaxs) => {
 
@@ -292,15 +295,15 @@ function calculateModiTax(cart, itemIndex, element, tax_settings, afterDicsount,
         modi.tax_id = taxId
         let promoDiscount = (modi.promotion_discount) ? modi.promotion_discount : 0
         let pointsDisouunt = (modi.points_discount) ? modi.points_discount : 0
-        promoDiscount = parseFloat(promoDiscount).toFixed(6)
+        promoDiscount = parseFloat(promoDiscount).toFixed(toFix)
         let afterDicsount = (modi.modifier_item_price * modi.quantity) * element.quantity - promoDiscount
         afterDicsount = afterDicsount - pointsDisouunt
-        afterDicsount = parseFloat(afterDicsount).toFixed(6)
+        afterDicsount = parseFloat(afterDicsount).toFixed(toFix)
 
         afterDicsount = (afterDicsount < 0) ? 0 : afterDicsount
 
         cart.cartTotal = parseFloat(cart.cartTotal) + parseFloat(afterDicsount)
-        cart.cartTotal = parseFloat(cart.cartTotal).toFixed(6)
+        cart.cartTotal = parseFloat(cart.cartTotal).toFixed(toFix)
 
         getTaxSettings2(taxId, tax_settings, iepsTax).then(async (modiItemTaxs) => {
 
@@ -412,12 +415,12 @@ function calculatePackageModiTax(cart, itemIndex, element, tax_settings, afterDi
           let pointsDisouunt = (modi.points_discount) ? modi.points_discount : 0
           let afterDicsount = (modi.modifier_item_price * modi.quantity) * element.quantity - promoDiscount
           afterDicsount = afterDicsount - pointsDisouunt
-          afterDicsount = parseFloat(afterDicsount).toFixed(6)
+          afterDicsount = parseFloat(afterDicsount).toFixed(toFix)
 
           afterDicsount = (afterDicsount < 0) ? 0 : afterDicsount
 
           cart.cartTotal = parseFloat(cart.cartTotal) + parseFloat(afterDicsount)
-          cart.cartTotal = parseFloat(cart.cartTotal).toFixed(6)
+          cart.cartTotal = parseFloat(cart.cartTotal).toFixed(toFix)
 
           getTaxSettings2(taxId, tax_settings, iepsTax).then(async (modiItemTaxs) => {
 
@@ -457,7 +460,7 @@ function calculatePackageModiTax(cart, itemIndex, element, tax_settings, afterDi
                   cart.tax_amount = parseFloat(cart.tax_amount).toFixed(6)
 
 
-                  // modiItemTax.base_price = that.taxType == 1 ? parseFloat(afterDicsount).toFixed(6) : (parseFloat(afterDicsount) - parseFloat(taxAmount)).toFixed(6)
+                  // modiItemTax.base_price = that.taxType == 1 ? parseFloat(afterDicsount).toFixed(toFix) : (parseFloat(afterDicsount) - parseFloat(taxAmount)).toFixed(toFix)
                   modiItemTaxArray.tax_amount = parseFloat(taxAmount).toFixed(6);
                   modiItemTaxArray.base_price = modiItemTaxArray.ieps_type ? lastPriceIeps : lastPrice;
                   modiItemTaxArray.tax_rate = modiItemTaxArray.ieps_type ? iepsTaxRate : modiItemTaxArray.tax_rate;
@@ -627,7 +630,7 @@ async function getBeforeTaxPriceOfItem(taxes, price, taxType, quantity) {
 
     // Calculate taxAmount based on tax type 1 = exclusive and 2 = inclusive
     if (taxType == 2) {
-      beforeTax = (beforeTax / (1 + totalTax / 100)).toFixed(6);
+      beforeTax = (beforeTax / (1 + totalTax / 100)).toFixed(toFix);
     }
 
     // ieps tax type = 1 precentage 2 absoulte 
@@ -636,20 +639,20 @@ async function getBeforeTaxPriceOfItem(taxes, price, taxType, quantity) {
         // Adjust beforeTax based on tax type
         if (beforeTax >= tax.tax_rate) {
           beforeTaxIeps = taxType == 1 ? beforeTax : beforeTax - tax.tax_rate * quantity;
-          beforeTaxIeps = parseFloat(beforeTaxIeps).toFixed(6)
+          beforeTaxIeps = parseFloat(beforeTaxIeps).toFixed(toFix)
           iepsTaxRate = tax.tax_rate * quantity / beforeTaxIeps
           iepsTaxRateQuantity = tax.tax_rate * quantity
           iepsTaxRate = parseFloat(iepsTaxRate)
-          iepsTaxAmount = (tax.tax_rate * quantity).toFixed(6);
+          iepsTaxAmount = (tax.tax_rate * quantity).toFixed(toFix);
         }
       }
       else if (tax.ieps_type && tax.ieps_type == 1) {
         beforeTaxIeps = beforeTax;
         iepsTaxRate = tax.tax_rate
-        iepsTaxAmount = (firstAmount - beforeTax - taxAmount).toFixed(6);
+        iepsTaxAmount = (firstAmount - beforeTax - taxAmount).toFixed(toFix);
       }
       else {
-        taxAmount = ((beforeTax * tax.tax_rate) / 100).toFixed(6);
+        taxAmount = ((beforeTax * tax.tax_rate) / 100).toFixed(toFix);
       }
     });
     resolve({ beforeTax, taxAmount, beforeTaxIeps, iepsTaxRate, iepsTaxAmount, iepsTaxRateQuantity });
@@ -787,9 +790,9 @@ async function calculateItemWiseSplit(cart, itemWiseItems) {
               }));
 
               // FINAL VALUES
-              p.tax = totalTax.toFixed(6);
-              p.amount = subtotal.toFixed(6);
-              p.due = subtotal.toFixed(6);
+              p.tax = totalTax.toFixed(toFix);
+              p.amount = subtotal.toFixed(toFix);
+              p.due = subtotal.toFixed(toFix);
           }
       });
       resolve(cart);
@@ -826,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(6);
-            p.amount = Number(remainingAmount).toFixed(6);
+            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(6));
-            const dueAmount = Number(Number(halfSplitTotalPerPerson).toFixed(6));
+            const taxAmount = Number(halfSplitTaxPerPerson).toFixed(toFix);
+            const amountPer = Number(halfSplitTotalPerPerson).toFixed(toFix);
 
-            p.tax = taxAmount.toFixed(6);
-            p.amount = dueAmount.toFixed(6);
-            p.due = dueAmount.toFixed(6);
+            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.66",
+  "version": "1.0.68",
   "description": "Package for cart calculations in which it performs discount distribution and tax distribution on order",
   "main": "index.js",
   "scripts": {