foodbot-cart-calculations 1.0.0

package/functions/taxCalculation.js

@@ -0,0 +1,542 @@
+function calculateTax2(cart, texSettings, taxType) {
+  return new Promise(function (resolve, reject) {
+    try {
+      cart.cartTotal = 0;
+      cart.tax_amount = 0;
+      cart.item_details.forEach(function (v) {
+        v.tax_amount = 0;
+      });
+      cart.item_details.forEach(function (v) {
+        if (!v.event && v.item_modifiers) {
+          v.item_modifiers.forEach(function (w) {
+            w.tax_amount = 0;
+            w.tax_array = [];
+          });
+          v.tax_array = [];
+        }
+      });
+      cart.item_details.forEach(function (v) {
+        if (v.isPackage == 1) {
+          v.package_items.forEach(function (w) {
+            w.modifiers.forEach(function (x) {
+              x.tax_amount = 0;
+              x.tax_array = [];
+            });
+            v.tax_array = [];
+          });
+          v.tax_array = [];
+        }
+      });
+      cart.merged_tax_array = [];
+
+      cart.item_details.forEach(async (element, itemIndex) => {
+        let total = 0;
+        if (!cart.item_details[itemIndex].tax_amount_modifier) {
+          cart.item_details[itemIndex].tax_amount_modifier = 0;
+        }
+        cart.item_details[itemIndex].total_tax_amount = 0;
+
+        let promoDiscount = (element.promotion_discount) ? element.promotion_discount : 0;
+        let pointsDiscount = (element.points_discount) ? element.points_discount : 0;
+
+        if (promoDiscount > 0) {
+          cart.item_details[itemIndex].item_event = 'update';
+        }
+        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(2);
+
+        let afterDiscount = element.item_price * element.quantity - promoDiscount;
+        afterDiscount = parseFloat(afterDiscount).toFixed(2);
+        afterDiscount = afterDiscount - pointsDiscount;
+        afterDiscount = parseFloat(afterDiscount).toFixed(2);
+        afterDiscount = (afterDiscount < 0) ? 0 : afterDiscount;
+        cart.cartTotal = parseFloat(cart.cartTotal) + parseFloat(afterDiscount);
+        cart.cartTotal = parseFloat(cart.cartTotal).toFixed(2);
+        total = +element.item_price;
+
+        if (element.isPackage == 1) {
+          let result = await calculatePackageItemTax(cart, itemIndex, element, texSettings, afterDiscount);
+          cart = result.cart;
+          element = result.element;
+        } else {
+          let result = await calculateItemTax(cart, itemIndex, element, texSettings, afterDiscount);
+          cart = result.cart;
+          element = result.element;
+        }
+
+        if (element.isPackage == 1) {
+          let result = await calculatePackageModiTax(cart, itemIndex, element, texSettings, afterDiscount);
+          cart = result.cart;
+          element = result.element;
+        } else {
+          let result = await calculateModiTax(cart, itemIndex, element, texSettings, afterDiscount);
+          cart = result.cart;
+          element = result.element;
+        }
+        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(2);
+          resolve(cart);
+        }
+
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+function calculateItemTax(cart, itemIndex, element, tax_settings, afterDicsount) {
+  return new Promise(async (resolve, reject) => {
+    getTaxSettings2(element.tax_id, tax_settings, element.ieps_tax).then(async (itemTaxs) => {
+      let lastPrice = afterDicsount
+      getBeforeTaxPriceOfItem(itemTaxs, lastPrice).then((resp) => {
+        lastPrice = +resp.beforeTax;
+        let itemTotalTax = 0;
+
+        itemTaxs.forEach(async (itemTaxArray, itemTaxIndex) => {
+          let startItemTax = JSON.parse(JSON.stringify(itemTaxArray))
+          if (!element.tax_array) {
+            element.tax_array = []
+          }
+          let taxAmount = 0
+          if (startItemTax.ieps_type && startItemTax.ieps_type == 2) {
+            taxAmount = lastPrice >= startItemTax.tax_rate ? startItemTax.tax_rate : 0;
+          } else {
+            taxAmount = (lastPrice * startItemTax.tax_rate) / 100;
+          }
+          taxAmount = parseFloat(taxAmount).toFixed(2)
+          itemTotalTax = (parseFloat(itemTotalTax) + parseFloat(taxAmount)).toFixed(2)
+
+          cart.tax_amount = parseFloat(cart.tax_amount) + parseFloat(taxAmount)
+          cart.tax_amount = parseFloat(cart.tax_amount).toFixed(2)
+          startItemTax.base_price = parseFloat(lastPrice).toFixed(2)
+          startItemTax.tax_amount = parseFloat(taxAmount).toFixed(2)
+          element.tax_array.push(JSON.parse(JSON.stringify(startItemTax)))
+          cart = await setTaxes(cart, JSON.parse(JSON.stringify(startItemTax)))
+
+          if (itemTaxIndex == itemTaxs.length - 1) {
+            element.tax_amount = itemTotalTax;
+            element.tax_amount = parseFloat(element.tax_amount).toFixed(2);
+            element.total_tax_amount = itemTotalTax;
+            element.total_tax_amount = parseFloat(element.total_tax_amount).toFixed(2);
+            element.tax_amount_modifier = parseFloat(itemTotalTax).toFixed(2);
+            resolve({ 'cart': cart, "element": element });
+          }
+        });
+      });
+    })
+  })
+}
+function calculatePackageItemTax(cart, itemIndex, element, tax_settings, afterDicsount) {
+  return new Promise(async (resolve, reject) => {
+    let itemTotalTax = 0;
+    element.package_items.forEach((packageItem, packageItemIndex) => {
+      element.package_items[packageItemIndex].tax_amount = 0
+      let promoDiscountPackage = (packageItem.promotion_discount) ? packageItem.promotion_discount : 0
+      let pointsDisouuntPackage = (packageItem.points_discount) ? packageItem.points_discount : 0
+
+      let defaultComboDiscount = packageItem.default_combo_discount ? packageItem.default_combo_discount : 0
+      let afterDicsountPackage = packageItem.price * element.quantity - promoDiscountPackage
+
+      afterDicsountPackage = parseFloat(afterDicsountPackage).toFixed(2)
+      afterDicsountPackage = afterDicsountPackage - pointsDisouuntPackage
+
+      afterDicsountPackage = parseFloat(afterDicsountPackage).toFixed(2)
+      afterDicsountPackage = afterDicsountPackage - defaultComboDiscount
+
+      afterDicsountPackage = parseFloat(afterDicsountPackage).toFixed(2)
+
+      getTaxSettings2(packageItem.tax_id, tax_settings, packageItem.ieps_tax).then(async (itemTaxs) => {
+
+        if (!element.package_items[packageItemIndex].tax_amount_modifier)
+          element.package_items[packageItemIndex].tax_amount_modifier = 0
+
+        element.package_items[packageItemIndex].total_tax_amount = 0
+
+        let lastPrice = afterDicsountPackage
+        let itemtaxAmount = 0;
+
+        await getBeforeTaxPriceOfItem(itemTaxs, lastPrice).then(async (resp) => {
+          lastPrice = +resp.beforeTax;
+
+          itemTaxs.forEach(async (itemTaxArray, itemTaxIndex) => {
+
+            let startItemTax = JSON.parse(JSON.stringify(itemTaxArray))
+
+            if (!element.package_items[packageItemIndex].tax_array) {
+              element.package_items[packageItemIndex].tax_array = []
+            }
+
+
+            let taxAmount = 0
+
+            if (startItemTax.ieps_type && startItemTax.ieps_type == 2) {
+              taxAmount = lastPrice >= startItemTax.tax_rate ? startItemTax.tax_rate : 0;
+            } else {
+              taxAmount = (lastPrice * startItemTax.tax_rate) / 100;
+            }
+
+            taxAmount = parseFloat(taxAmount).toFixed(2)
+            itemTotalTax = (parseFloat(itemTotalTax) + parseFloat(taxAmount)).toFixed(2)
+            itemtaxAmount = (parseFloat(itemtaxAmount) + parseFloat(taxAmount)).toFixed(2);
+
+            cart.tax_amount = parseFloat(cart.tax_amount) + parseFloat(taxAmount)
+            cart.tax_amount = parseFloat(cart.tax_amount).toFixed(2)
+            startItemTax.base_price = parseFloat(lastPrice).toFixed(2)
+            startItemTax.tax_amount = parseFloat(taxAmount).toFixed(2)
+
+            element.package_items[packageItemIndex].tax_array.push(JSON.parse(JSON.stringify(startItemTax)));
+            cart = await setTaxes(cart, JSON.parse(JSON.stringify(startItemTax)))
+
+            //push array yo package
+            element = await setPackageTaxes(element, JSON.parse(JSON.stringify(startItemTax)));
+            element.package_items[packageItemIndex].tax_amount = parseFloat(itemtaxAmount).toFixed(2);
+            element.package_items[packageItemIndex].total_tax_amount = parseFloat(itemtaxAmount).toFixed(2);
+            // element.package_items[packageItemIndex].tax_amount_modifier = itemTotalTax
+          });
+        });
+
+        element.tax_amount = (parseFloat(element.tax_amount) + parseFloat(itemtaxAmount)).toFixed(2)
+        element.total_tax_amount = (parseFloat(element.total_tax_amount) + parseFloat(element.package_items[packageItemIndex].tax_amount)).toFixed(2)
+      })
+      if (packageItemIndex == element.package_items.length - 1) {
+        element.tax_amount_modifier = 0;
+        resolve({ 'cart': cart, "element": element });
+      }
+    })
+  })
+}
+function calculateModiTax(cart, itemIndex, element, tax_settings, afterDicsount) {
+  return new Promise(async (resolve, reject) => {
+    if (element && element.item_modifiers && element.item_modifiers.length > 0) {
+      let itemModiTotalTax = 0
+      element.item_modifiers.forEach((modi, modiIndex) => {
+        let taxId = []
+        let iepsTax;
+
+        if (modi.is_tax_rate_same == 1) {
+          if (modi.linked_product && modi.linked_product.product_tax_id) {
+            taxId = modi.linked_product.product_tax_id
+            iepsTax = modi.linked_product.ieps_tax
+          } else {
+            taxId = element.tax_id
+            iepsTax = []
+          }
+        }
+        else {
+          if (modi.linked_product && modi.linked_product.product_tax_id) {
+            taxId = modi.linked_product.product_tax_id
+          } else {
+            taxId = modi.tax_id
+          }
+        }
+
+        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(2)
+        let afterDicsount = (modi.modifier_item_price * modi.quantity) * element.quantity - promoDiscount
+        afterDicsount = afterDicsount - pointsDisouunt
+        afterDicsount = parseFloat(afterDicsount).toFixed(2)
+
+        afterDicsount = (afterDicsount < 0) ? 0 : afterDicsount
+
+        cart.cartTotal = parseFloat(cart.cartTotal) + parseFloat(afterDicsount)
+        cart.cartTotal = parseFloat(cart.cartTotal).toFixed(2)
+
+        getTaxSettings2(taxId, tax_settings, iepsTax).then(async (modiItemTaxs) => {
+
+          let lastPrice = afterDicsount
+          if (modiItemTaxs.length > 0) {
+            await getBeforeTaxPriceOfItem(modiItemTaxs, lastPrice).then((resp) => {
+              lastPrice = +resp.beforeTax;
+
+              modiItemTaxs.forEach(async (modiItemTax, modiTaxItemIndex) => {
+
+                let modiItemTaxArray = JSON.parse(JSON.stringify(modiItemTax))
+
+                if (!element.item_modifiers[modiIndex].tax_array)
+                  element.item_modifiers[modiIndex].tax_array = []
+                if (!element.item_modifiers[modiIndex].tax_amount)
+                  element.item_modifiers[modiIndex].tax_amount = 0
+
+                let taxAmount = 0
+
+                if (modiItemTaxArray.ieps_type && modiItemTaxArray.ieps_type == 2) {
+                  taxAmount = lastPrice >= modiItemTaxArray.tax_rate ? modiItemTaxArray.tax_rate : 0;
+                } else {
+                  taxAmount = (lastPrice * modiItemTaxArray.tax_rate) / 100;
+                }
+
+                taxAmount = parseFloat(taxAmount).toFixed(2)
+                itemModiTotalTax = itemModiTotalTax + taxAmount
+                cart.tax_amount = parseFloat(cart.tax_amount) + parseFloat(taxAmount)
+                cart.tax_amount = parseFloat(cart.tax_amount).toFixed(2)
+
+                modiItemTaxArray.base_price = parseFloat(lastPrice).toFixed(2)
+                modiItemTaxArray.tax_amount = parseFloat(taxAmount).toFixed(2)
+
+                element.item_modifiers[modiIndex].tax_array.push(JSON.parse(JSON.stringify(modiItemTaxArray)))
+                cart = await setTaxes(cart, JSON.parse(JSON.stringify(modiItemTaxArray)));
+
+                element.item_modifiers[modiIndex].tax_amount = parseFloat(element.item_modifiers[modiIndex].tax_amount) + parseFloat(taxAmount);
+                element.item_modifiers[modiIndex].tax_amount = parseFloat(element.item_modifiers[modiIndex].tax_amount).toFixed(2)
+                element.tax_amount_modifier = parseFloat(element.tax_amount_modifier) + parseFloat(taxAmount)
+                element.tax_amount_modifier = parseFloat(element.tax_amount_modifier).toFixed(2)
+                element.total_tax_amount = parseFloat(element.total_tax_amount) + parseFloat(taxAmount)
+                element.total_tax_amount = parseFloat(element.total_tax_amount).toFixed(2)
+
+                if (modiItemTaxs.length - 1 == modiTaxItemIndex) {
+                  resolve({ 'cart': cart, "element": element });
+                }
+
+
+              });
+            })
+          }
+          else {
+            resolve({ 'cart': cart, "element": element });
+          }
+        })
+      })
+    }
+    else {
+      resolve({ 'cart': cart, "element": element });
+    }
+  })
+}
+function calculatePackageModiTax(cart, itemIndex, element, tax_settings, afterDicsount) {
+  return new Promise(async (resolve, reject) => {
+    element.package_items.forEach((packageItem, packageItemIndex) => {
+      element.package_items[packageItemIndex].tax_amount_modifier = 0
+      if (packageItem.modifiers.length > 0) {
+        let itemModiTotalTax = 0
+        packageItem.modifiers.forEach((modi, modiIndex) => {
+          let taxId = []
+          let iepsTax;
+          if (modi.is_tax_rate_same == 1) {
+            if (modi.linked_product && modi.linked_product.product_tax_id) {
+              taxId = modi.linked_product.product_tax_id
+              iepsTax = modi.linked_product.ieps_tax
+            } else {
+              taxId = packageItem.tax_id
+              iepsTax = []
+            }
+          }
+          else {
+            if (modi.linked_product && modi.linked_product.product_tax_id) {
+              taxId = modi.linked_product.product_tax_id
+            } else {
+              taxId = modi.tax_id
+            }
+          }
+
+          modi.tax_id = taxId
+
+          let promoDiscount = (modi.promotion_discount) ? modi.promotion_discount : 0
+          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(2)
+
+          afterDicsount = (afterDicsount < 0) ? 0 : afterDicsount
+
+          cart.cartTotal = parseFloat(cart.cartTotal) + parseFloat(afterDicsount)
+          cart.cartTotal = parseFloat(cart.cartTotal).toFixed(2)
+
+          getTaxSettings2(taxId, tax_settings, iepsTax).then(async (modiItemTaxs) => {
+
+            let lastPrice = afterDicsount
+
+            if (modiItemTaxs.length > 0) {
+              await getBeforeTaxPriceOfItem(modiItemTaxs, lastPrice).then((resp) => {
+                lastPrice = +resp.beforeTax;
+                modiItemTaxs.forEach(async (modiItemTax, modiTaxItemIndex) => {
+
+                  if (!element.package_items[packageItemIndex].modifiers[modiIndex].tax_array) {
+                    element.package_items[packageItemIndex].modifiers[modiIndex].tax_array = []
+                  }
+
+                  if (!element.package_items[packageItemIndex].modifiers[modiIndex].tax_amount) {
+                    element.package_items[packageItemIndex].modifiers[modiIndex].tax_amount = 0
+                  }
+
+                  let taxAmount = 0
+
+                  if (modiItemTax.ieps_type && modiItemTax.ieps_type == 2) {
+                    taxAmount = lastPrice >= modiItemTax.tax_rate ? modiItemTax.tax_rate : 0;
+                  } else {
+                    taxAmount = (lastPrice * modiItemTax.tax_rate) / 100;
+                  }
+                  taxAmount = parseFloat(taxAmount).toFixed(2)
+
+                  itemModiTotalTax = itemModiTotalTax + taxAmount;
+                  cart.tax_amount = parseFloat(cart.tax_amount) + parseFloat(taxAmount)
+                  cart.tax_amount = parseFloat(cart.tax_amount).toFixed(2)
+
+
+                  // modiItemTax.base_price = that.taxType == 1 ? parseFloat(afterDicsount).toFixed(2) : (parseFloat(afterDicsount) - parseFloat(taxAmount)).toFixed(2)
+                  modiItemTax.base_price = lastPrice
+                  modiItemTax.tax_amount = parseFloat(taxAmount).toFixed(2)
+
+                  // cart[itemIndex].item_modifiers[modiIndex].tax_array.push(JSON.parse(JSON.stringify(modiItemTax)))
+                  element.package_items[packageItemIndex].modifiers[modiIndex].tax_array.push(JSON.parse(JSON.stringify(modiItemTax)))
+                  cart = await setTaxes(cart, JSON.parse(JSON.stringify(modiItemTax)))
+
+                  element.package_items[packageItemIndex].modifiers[modiIndex].tax_amount = parseFloat(element.package_items[packageItemIndex].modifiers[modiIndex].tax_amount) + parseFloat(taxAmount)
+                  element.package_items[packageItemIndex].tax_amount_modifier = (parseFloat(element.package_items[packageItemIndex].tax_amount_modifier) + parseFloat(taxAmount)).toFixed(2)
+                  element.package_items[packageItemIndex].total_tax_amount = (parseFloat(element.package_items[packageItemIndex].total_tax_amount) + parseFloat(taxAmount)).toFixed(2)
+                  element.tax_amount_modifier = (parseFloat(element.tax_amount_modifier) + parseFloat(taxAmount)).toFixed(2)
+                  element.total_tax_amount = (parseFloat(element.total_tax_amount) + parseFloat(taxAmount)).toFixed(2)
+
+                  if (modiItemTaxs.length - 1 == modiTaxItemIndex)
+                    resolve({ 'cart': cart, "element": element });
+
+                });
+              })
+            }
+            else {
+              resolve({ 'cart': cart, "element": element });
+            }
+
+
+          })
+
+        })
+      }
+      else {
+        resolve({ 'cart': cart, "element": element });
+      }
+    });
+  })
+}
+function setPackageTaxes(item, tax_array) {
+  return new Promise(async (resolve, reject) => {
+    let index = -1;
+
+    if (tax_array.ieps_type) {
+      index = item.tax_array.findIndex((res) => res.tax_id == tax_array.tax_id && res.ieps_type == tax_array.ieps_type);
+    } else {
+      index = item.tax_array.findIndex((res) => !res.ieps_type && res.tax_id == tax_array.tax_id);
+    }
+
+    if (index !== -1) {
+      item.tax_array[index].tax_amount = (parseFloat(item.tax_array[index].tax_amount) + parseFloat(tax_array.tax_amount)).toFixed(2);
+      item.tax_array[index].base_price = (parseFloat(item.tax_array[index].base_price) + parseFloat(tax_array.base_price)).toFixed(2);
+    } else {
+      item.tax_array.push(tax_array);
+    }
+    resolve(item);
+  })
+}
+
+function getTaxSettings2(itemTax, taxSettings, iepsTax = '') {
+  return new Promise(function (resolve, reject) {
+    let count = 0;
+    let settings = [];
+    let taxes = [];
+
+    if (itemTax && itemTax !== undefined) {
+      itemTax = !isJson(itemTax) ? itemTax : JSON.parse(itemTax);
+      taxes = [...itemTax];
+
+      // Handle ieps tax
+      if (iepsTax && iepsTax.status && iepsTax.status == 1 && iepsTax.ieps_details) {
+        if (iepsTax.ieps_details.type == 1) {
+          taxes.push(iepsTax.ieps_details);
+        } else {
+          const absoluteTax = {
+            base_price_effected: 0,
+            tax_sequence: 1,
+            tax_label: 'IEPS',
+            ieps_type: 2,
+            tax_id: iepsTax.ieps_details.tax_id,
+            tax_rate: iepsTax.ieps_details.tax_id,
+          };
+          settings.push(absoluteTax);
+        }
+      }
+
+      taxes.forEach((element) => {
+        count++;
+        let index = taxSettings.findIndex((res) => res.tax_id == element.tax_id);
+
+        if (index >= 0) {
+          const taxDetail = { ...taxSettings[index] };
+          if (element.type) {
+            taxDetail.tax_label = 'IEPS';
+            taxDetail.ieps_type = 1;
+          }
+          settings.push(taxDetail);
+        }
+
+        if (count == taxes.length) {
+          settings = settings.sort((a, b) => (Number(b.tax_sequence) < Number(a.tax_sequence) ? 1 : -1));
+          resolve(settings);
+        }
+      });
+    } else {
+      resolve([]);
+    }
+  });
+}
+
+function isJson(str) {
+  try {
+    JSON.parse(str);
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+
+async function getBeforeTaxPriceOfItem(taxes, price) {
+  return new Promise((resolve, reject) => {
+    let taxType = this.taxType;
+    let beforeTax = parseFloat(price);
+    let taxRate = 0;
+    let taxAmount = 0;
+    let itemPriceForTaxCal = 0;
+
+    taxes.forEach((tax) => {
+      if (tax.ieps_type && tax.ieps_type == 2) {
+        // Adjust beforeTax based on tax type
+        if (beforeTax >= tax.tax_rate) {
+          itemPriceForTaxCal = (taxType == 1) ? beforeTax + tax.tax_rate : beforeTax - tax.tax_rate;
+        }
+      } else {
+        taxRate += parseFloat(tax.tax_rate);
+      }
+    });
+
+    // Calculate taxAmount based on tax type 1 = exclusive and 2 = inclusive
+    if (taxType == 1) {
+      taxAmount = itemPriceForTaxCal == 0 ? ((beforeTax * taxRate) / 100).toFixed(6) : ((itemPriceForTaxCal * taxRate) / 100).toFixed(6);
+    } else {
+      beforeTax = itemPriceForTaxCal == 0 ? (beforeTax / parseFloat(1 + taxRate / 100)).toFixed(6) : (itemPriceForTaxCal / (1 + taxRate / 100)).toFixed(6);
+      taxAmount = itemPriceForTaxCal == 0 ? (price - beforeTax).toFixed(6) : (itemPriceForTaxCal - beforeTax).toFixed(6);
+    }
+    resolve({ beforeTax, taxAmount });
+  });
+}
+function setTaxes(cart, tax_array) {
+  return new Promise(async (resolve, reject) => {
+    let index = cart.merged_tax_array.findIndex((res) => res.tax_id == tax_array.tax_id)
+    if (index != -1) {
+      cart.merged_tax_array[index].tax_amount = parseFloat(cart.merged_tax_array[index].tax_amount) + parseFloat(tax_array.tax_amount)
+      cart.merged_tax_array[index].tax_amount = parseFloat(cart.merged_tax_array[index].tax_amount).toFixed(2)
+
+      cart.merged_tax_array[index].base_price = parseFloat(cart.merged_tax_array[index].base_price) + parseFloat(tax_array.base_price)
+      cart.merged_tax_array[index].base_price = parseFloat(cart.merged_tax_array[index].base_price).toFixed(2)
+
+    }
+    else {
+      cart.merged_tax_array.push(tax_array)
+    }
+    resolve(cart);
+  })
+}
+
+module.exports = { calculateTax2 }

package/main.js

@@ -0,0 +1,77 @@
+const calculation = require('./calculations');
+async function calculateTax(inputJSON) {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const requiredFields = ['tax_type', 'order_items', 'tax_settings'];
+      const missingFields = [];
+      for (const field of requiredFields) {
+        if (!inputJSON || !inputJSON[field]) {
+          missingFields.push(field);
+        }
+      }
+      if (missingFields.length > 0) {
+        resolve({
+          'status': 'fail',
+          'status_code': 400,
+          'message': 'Field required',
+          'missing_fields': missingFields,
+        });
+      } else {
+        let continueFlag = true;
+        if (inputJSON.promotion_applied) {
+          const promotionKeys = ['offer_discount_type', 'oo_offer_value', 'offer_id'];
+          const missingPromotionKeys = promotionKeys.filter(key => !inputJSON.promotion_applied[key]);
+          if (missingPromotionKeys.length > 0) {
+            continueFlag = false;
+            resolve({
+              'status': 'fail',
+              'status_code': 400,
+              'message': 'Field required for promotion_applied',
+              'missing_fields': missingPromotionKeys,
+            });
+          }
+        }
+        if (continueFlag) {
+          calculation.applyDistribution(inputJSON).then(result => {
+            const optionalFields = ['order_type', 'restaurant_id', 'branch_id', 'request_id'];
+            const missingOptionalFields = optionalFields.filter(field => !inputJSON[field]);
+            if (missingOptionalFields.length > 0) {
+              resolve({
+                'status': 'success',
+                'status_code': 201,
+                'message': 'Tax calculated successfully with few details missing',
+                'missing_optional_fields': missingOptionalFields,
+                'data': result
+              });
+            } else {
+              resolve({
+                'status': 'success',
+                'status_code': 200,
+                'message': 'Tax calculated successfully',
+                'data': result
+              });
+            }
+          }).catch(err => {
+            resolve({
+              "status": 'fail',
+              "status_code": 500,
+              "message": 'Error during tax calculation',
+              "error": err.stack,
+            });
+          })
+        }
+      }
+    } catch (error) {
+      resolve({
+        'status': 'error',
+        'status_code': 500,
+        'message': 'Internal server error',
+        'error': error.stack,
+      });
+    }
+  })
+}
+
+module.exports = { calculateTax }
+
+

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "foodbot-cart-calculations",
+  "version": "1.0.0",
+  "description": "Package for cart calculations in which it performs discount distribution and tax distribution on order",
+  "main": "main.js",
+  "scripts": {
+    "test": "npm start"
+  },
+  "author": "Foodbot",
+  "license": "ISC"
+}