@darkpos/pricing 1.0.44 → 1.0.46

package/lib/modifier/getItemModifiers.js

@@ -6,9 +6,7 @@ module.exports = ({ actions }) =>
     });
 
     const enabledModifiers = matchedModifiers.filter(
-      each =>
-        (actions.isDefault(each) || actions.isRequired(each)) &&
-        !(actions.isGroupOfValues(each) || actions.isGroupOfModifiers(each))
+      each => actions.isDefault(each) || actions.isRequired(each)
     );
 
     const relatedModifiers = enabledModifiers

package/lib/modifier/hasPaymentMethodType.js

@@ -0,0 +1,14 @@
+module.exports = ({ actions }) =>
+  function hasPaymentMethodType({
+    paymentModifier,
+    paymentMethod,
+    paymentType,
+  }) {
+    return (
+      actions.isPaymentModifier(paymentModifier) &&
+      paymentModifier.conditions.rules.some(
+        rule =>
+          rule.value.includes(paymentMethod) || rule.value.includes(paymentType)
+      )
+    );
+  };

package/lib/modifier/index.js

@@ -117,7 +117,6 @@ const isCredit = require('./isCredit');
 const purifyModifiers = require('./purifyModifiers');
 const sort = require('./sort');
 const isPaymentModifier = require('./isPaymentModifier');
-const createPaymentModifier = require('./createPaymentModifier');
 const isSubtract = require('./isSubtract');
 const isFixed = require('./isFixed');
 const isFixedAdd = require('./isFixedAdd');
@@ -127,7 +126,8 @@ const mutateModifier = require('./mutateModifier');
 const isFixedDiscount = require('./isFixedDiscount');
 const removeLocked = require('./removeLocked');
 const hasItems = require('./hasItems');
-const getLockedModifiers = require('./getLockedModifiers');
+const removeGroupData = require('./removeGroupData');
+const isRelatedModifier = require('./isRelatedModifier');
 const getGroupedModifiers = require('./getGroupedModifiers');
 const getNotesToModifierTags = require('./getNotesToModifierTags');
 const isOptionsOverride = require('./isOptionsOverride');
@@ -137,6 +137,15 @@ const validateNumberCondition = require('./validateNumberCondition');
 const validateRequiredModifiers = require('./validateRequiredModifiers');
 const validateDateDaysDiff = require('./validateDateDaysDiff');
 const validateInArr = require('./validateInArr');
+const isPercentage = require('./isPercentage');
+const getChildren = require('./getChildren');
+const getComputedAmount = require('./getComputedAmount');
+const hasPaymentMethodType = require('./hasPaymentMethodType');
+const calculatePaymentModifier = require('./calculatePaymentModifier');
+const calculatePaymentDiscountModifier = require('./calculatePaymentDiscountModifier');
+const calculatePaymentFeeModifier = require('./calculatePaymentFeeModifier');
+const isCalculatedPaymentModifier = require('./isCalculatedPaymentModifier');
+const isChild = require('./isChild');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -265,17 +274,17 @@ const modifierActions = (deps = {}) => {
     purifyModifiers: purifyModifiers(innerDeps),
     sort: sort(innerDeps),
     isPaymentModifier: isPaymentModifier(innerDeps),
-    createPaymentModifier: createPaymentModifier(innerDeps),
     isSubtract: isSubtract(innerDeps),
     isFixed: isFixed(innerDeps),
     isFixedDiscount: isFixedDiscount(innerDeps),
     removeLocked: removeLocked(innerDeps),
     hasItems: hasItems(innerDeps),
-    getLockedModifiers: getLockedModifiers(innerDeps),
     isFixedAdd: isFixedAdd(innerDeps),
     isFee: isFee(innerDeps),
     isAdd: isAdd(innerDeps),
     mutateModifier: mutateModifier(innerDeps),
+    removeGroupData: removeGroupData(innerDeps),
+    isRelatedModifier: isRelatedModifier(innerDeps),
     getGroupedModifiers: getGroupedModifiers(innerDeps),
     getNotesToModifierTags: getNotesToModifierTags(innerDeps),
     isOptionsOverride: isOptionsOverride(innerDeps),
@@ -286,6 +295,16 @@ const modifierActions = (deps = {}) => {
     validateDateDaysDiff: validateDateDaysDiff(innerDeps),
     validateInArr: validateInArr(innerDeps),
     areConditionsMet: areConditionsMet(innerDeps),
+    isPercentage: isPercentage(innerDeps),
+    getChildren: getChildren(innerDeps),
+    getComputedAmount: getComputedAmount(innerDeps),
+    hasPaymentMethodType: hasPaymentMethodType(innerDeps),
+    calculatePaymentModifier: calculatePaymentModifier(innerDeps),
+    calculatePaymentDiscountModifier:
+      calculatePaymentDiscountModifier(innerDeps),
+    calculatePaymentFeeModifier: calculatePaymentFeeModifier(innerDeps),
+    isCalculatedPaymentModifier: isCalculatedPaymentModifier(innerDeps),
+    isChild: isChild(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isCalculatedPaymentModifier.js

@@ -0,0 +1,4 @@
+module.exports = ({ actions }) =>
+  function isCalculatedPaymentModifier(modifier) {
+    return !!actions.getProperty(modifier, 'isCalculatedPaymentModifier');
+  };

package/lib/modifier/isChild.js

@@ -0,0 +1,6 @@
+module.exports = () =>
+  function isChild({ parentModifier, modifier }) {
+    if (!parentModifier || !modifier) return false;
+
+    return modifier._parentId === parentModifier._id;
+  };

package/lib/modifier/isDiscount.js

@@ -1,6 +1,10 @@
-module.exports = ({ constants }) => {
+module.exports = ({ constants, actions }) => {
   const { Modifier } = constants;
   return function isDiscount(modifier) {
-    return !!(modifier && modifier.type === Modifier.Types.DISCOUNT);
+    return !!(
+      modifier &&
+      (modifier.type === Modifier.Types.DISCOUNT ||
+        actions.isSubtract(modifier))
+    );
   };
 };

package/lib/modifier/isFee.js

@@ -1,6 +1,9 @@
-module.exports = ({ constants }) => {
+module.exports = ({ constants, actions }) => {
   const { Modifier } = constants;
   return function isFee(modifier) {
-    return !!(modifier && modifier.type === Modifier.Types.FEE);
+    return !!(
+      modifier &&
+      (modifier.type === Modifier.Types.FEE || actions.isAdd(modifier))
+    );
   };
 };

package/lib/modifier/isPaymentMethodModifier.js

@@ -3,6 +3,9 @@ module.exports = () =>
     return !!(
       modifier &&
       modifier.conditions &&
-      modifier.conditions.some(condition => condition.key === 'paymentMethods')
+      Array.isArray(modifier.conditions.rules) &&
+      modifier.conditions.rules.some(
+        condition => condition.key === 'paymentMethods'
+      )
     );
   };

package/lib/modifier/isPaymentTypeModifier.js

@@ -3,6 +3,9 @@ module.exports = () =>
     return !!(
       modifier &&
       modifier.conditions &&
-      modifier.conditions.some(condition => condition.key === 'paymentTypes')
+      Array.isArray(modifier.conditions.rules) &&
+      modifier.conditions.rules.some(
+        condition => condition.key === 'paymentTypes'
+      )
     );
   };

package/lib/modifier/isPercentage.js

@@ -0,0 +1,10 @@
+module.exports = ({ constants }) => {
+  const { Modifier } = constants;
+  return function isFixed(modifier) {
+    return !!(
+      modifier &&
+      modifier.compute &&
+      modifier.compute.type === Modifier.Compute.Types.PERCENTAGE
+    );
+  };
+};

package/lib/modifier/isRelatedModifier.js

@@ -0,0 +1,13 @@
+module.exports = ({ actions }) =>
+  function isRelatedModifier({ _id, modifier }) {
+    if (!modifier || !_id) return false;
+
+    if (actions.isGroupOfModifiers(modifier)) {
+      const relatedModifiers = modifier.properties.group.modifiers;
+      return [actions.removeGroupData({ modifier }), ...relatedModifiers].some(
+        relatedModifier => isRelatedModifier({ _id, modifier: relatedModifier })
+      );
+    }
+
+    return modifier._id === _id || modifier.modifierId === _id;
+  };

package/lib/modifier/removeGroupData.js

@@ -0,0 +1,20 @@
+module.exports = ({ constants }) => {
+  const { Modifier } = constants;
+
+  return function removeGroupData({ modifier }) {
+    if (!modifier) return modifier;
+
+    return {
+      ...modifier,
+      properties:
+        modifier.properties && modifier.properties.group
+          ? { ...modifier.properties, group: null }
+          : modifier.properties,
+      attributes: Array.isArray(modifier.attributes)
+        ? modifier.attributes.filter(
+            attribute => attribute !== Modifier.Attributes.GROUP
+          )
+        : modifier.attributes,
+    };
+  };
+};

package/lib/modifier/sort.js

@@ -6,6 +6,34 @@ module.exports = ({ actions }) => {
       const aVal = actions.getProperty(a, key);
       const bVal = actions.getProperty(b, key);
 
+      const aIsPaymentModifier = actions.isPaymentModifier(a);
+      const bIsPaymentModifier = actions.isPaymentModifier(b);
+      const aIsCalculatedPaymentModifier =
+        actions.isCalculatedPaymentModifier(a);
+      const bIsCalculatedPaymentModifier =
+        actions.isCalculatedPaymentModifier(b);
+
+      if (aIsCalculatedPaymentModifier && bIsPaymentModifier && aVal === null) {
+        return -1;
+      }
+      if (bIsCalculatedPaymentModifier && aIsPaymentModifier && bVal === null) {
+        return -1;
+      }
+
+      if (
+        (aIsPaymentModifier || aIsCalculatedPaymentModifier) &&
+        aVal === null
+      ) {
+        return 1;
+      }
+
+      if (
+        (bIsPaymentModifier || bIsCalculatedPaymentModifier) &&
+        bVal === null
+      ) {
+        return 1;
+      }
+
       if (aVal == null && bVal === null) {
         return 0;
       }

package/lib/order/addItemModifier.js

@@ -173,7 +173,14 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     const customer = actions.getCustomer(order);
     const contains =
       !_.isEmpty(item.modifiers) &&
-      modifierActions.contains(item.modifiers, modifier);
+      modifierActions.contains(
+        item.modifiers.filter(
+          mod =>
+            !modifierActions.isRequired(mod) &&
+            !modifierActions.isGroupOfModifiers(mod)
+        ),
+        modifier
+      );
 
     const usingCount = contains
       ? modifierActions.getUsingCount(item.modifiers, modifier)

package/lib/order/applyPayment.js

@@ -0,0 +1,61 @@
+/**
+  const options = {
+    "5d9f80ae6065e52e04686e03": {
+      amount: 10,
+      items: {
+        "5d9f80dc6065e52e04686e3c": {
+          status: { picked: { value: true } },
+          total: 0,
+          totalPaid: 5,
+        },
+        "5d9f80dc6065e52e04686e3c": {
+          status: { picked: { value: true } },
+          total: 0,
+          totalPaid: 5,
+        },
+        "5d9f80dc6065e52e04686e3c": {
+          status: { picked: { value: true } },
+          total: 0,
+          totalPaid: 5,
+        },
+        "5d9f80dc6065e52e04686e3c": {
+          status: { picked: { value: true } },
+          total: 0,
+          totalPaid: 5,
+        },
+      }
+    }
+  }
+ */
+module.exports = ({ utils, itemActions }) =>
+  function applyPayment(options, amountToProcess = 0) {
+    const optionsWithAmount = options;
+    let amount = amountToProcess;
+
+    Object.keys(options).forEach(orderId => {
+      const order = options[orderId];
+      const { items } = order;
+
+      Object.keys(items).forEach(itemId => {
+        const item = items[itemId];
+
+        const { amountToAssign, remainingAmount, isPaid } =
+          itemActions.getAmounts(item, amount);
+        amount = remainingAmount;
+
+        // assign amount to item
+        items[itemId] = {
+          ...item,
+          orderId,
+          amount: amountToAssign,
+          totalPaid: utils.math.add(item.totalPaid, amountToAssign),
+          status: {
+            ...item.status,
+            paid: { value: isPaid, date: new Date() },
+          },
+        };
+      });
+    });
+
+    return optionsWithAmount;
+  };

package/lib/order/calculate.js

@@ -2,7 +2,7 @@
 /**
  * return calculated Order
  */
-module.exports = ({ _, actions, itemActions, modifierActions }) =>
+module.exports = ({ _, actions, itemActions, modifierActions, utils }) =>
   function calculateorder(inputOrder, opts = {}) {
     if (!inputOrder) return inputOrder;
     const order = _.cloneDeep(inputOrder);
@@ -20,24 +20,29 @@ module.exports = ({ _, actions, itemActions, modifierActions }) =>
       startRequestDate,
       endRequestDate,
     };
-    const sortedOrderModifiers = modifierActions.sort(
-      modifierActions.removeLocked(order.modifiers)
-    );
+    const sortedOrderModifiers = modifierActions.sort(order.modifiers || []);
 
     let itemsWNIM = items.map(item =>
       itemActions.removeModifiers({ item, modifiers: sortedOrderModifiers })
     );
 
-    itemsWNIM = itemActions.calculate(itemsWNIM, options);
+    itemsWNIM = itemActions.calculate(itemsWNIM, {
+      ...options,
+      lockPaymentModifiers: !!(
+        options.lockPaymentModifiers && !sortedOrderModifiers.length
+      ),
+    });
 
     const newOrder = {
       ...order,
-      ...itemActions.getTotals(itemsWNIM),
+      ...itemActions.getItemsTotals(itemsWNIM),
       items: itemsWNIM,
     };
 
     if (!sortedOrderModifiers.length) return newOrder;
 
+    itemsWNIM = itemActions.calculate(itemsWNIM, {});
+
     let tempItems = itemsWNIM || items;
     let itemsWIM = _.cloneDeep(tempItems);
     let prvSort = null;
@@ -65,21 +70,14 @@ module.exports = ({ _, actions, itemActions, modifierActions }) =>
 
       if (isCredit) {
         const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
-        computedTotal = itemActions.getTotals(calculatedItemWIM).total;
+        computedTotal = itemActions.getItemsTotals(calculatedItemWIM).total;
       }
 
       if (modifierActions.hasItems({ modifier })) {
         tempItems = itemActions.getItems(tempItems, modifier.items);
       }
 
-      tempItems = tempItems.map(tempItem =>
-        itemActions.removeModifiers({
-          item: tempItem,
-          modifiers: modifierActions.getLockedModifiers(tempItem.modifiers),
-        })
-      );
-
-      computedTotal = itemActions.getTotals(tempItems).total;
+      computedTotal = itemActions.getItemsTotals(tempItems).total;
 
       const itemsModifiers = itemActions.addIndirectModifier({
         orderTotal: computedTotal,
@@ -99,9 +97,29 @@ module.exports = ({ _, actions, itemActions, modifierActions }) =>
 
     const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
 
+    if (calculatedItemWIM.length > 1) {
+      const { total, subTotalsTotal } = calculatedItemWIM.reduce(
+        (acc, item) => ({
+          total: utils.math.add(acc.total, item.total),
+          subTotalsTotal: utils.math.add(
+            acc.subTotalsTotal,
+            utils.math.add(item.subTotals._actual, item.subTotals._xincluded)
+          ),
+        }),
+        { total: 0, subTotalsTotal: 0 }
+      );
+      const difference = utils.math.sub(subTotalsTotal, total);
+
+      if (difference > 0) {
+        calculatedItemWIM[0].total = utils.math.toDecimalPlaces(
+          utils.math.add(calculatedItemWIM[0].total, difference)
+        );
+      }
+    }
+
     return {
       ...order,
-      ...itemActions.getTotals(calculatedItemWIM),
+      ...itemActions.getItemsTotals(calculatedItemWIM),
       items: calculatedItemWIM,
     };
   };

package/lib/order/getBalance.js

@@ -3,7 +3,6 @@ module.exports = ({ utils }) => {
   return function getBalance({ order }) {
     if (!order) return 0;
     if (Array.isArray(order)) return 0;
-
     return math.sub(order.total, order.totalPaid);
   };
 };

package/lib/order/getOrdersBalance.js

@@ -0,0 +1,8 @@
+module.exports = ({ utils, actions }) =>
+  function getOrdersBalance({ orders = [] }) {
+    const result = orders.reduce(
+      (acc, order) => utils.math.add(acc, actions.getBalance({ order })),
+      0
+    );
+    return result;
+  };

package/lib/order/index.js

@@ -1,7 +1,7 @@
 //
 const getTotalPieces = require('./getTotalPieces');
 const getStartDate = require('./getStartDate');
-const getBalance = require('./getBalance');
+const getOrdersBalance = require('./getOrdersBalance');
 const getEndDate = require('./getEndDate');
 const isNew = require('./isNew');
 const getSelectedItem = require('./getSelectedItem');
@@ -57,8 +57,6 @@ const removeApplyModifier = require('./removeApplyModifier');
 const getCustomerSubscriptions = require('./getCustomerSubscriptions');
 const getCustomerSubscriptionsByItem = require('./getCustomerSubscriptionsByItem');
 const hasRemainingSubscription = require('./hasRemainingSubscription');
-const removeModifiersWithPaymentMethods = require('./removeModifiersWithPaymentMethods');
-const removeModifiersWithPaymentTypes = require('./removeModifiersWithPaymentTypes');
 const getItemsToPay = require('./getItemsToPay');
 const hasItem = require('./hasItem');
 const getNumberOfItems = require('./getNumberOfItems');
@@ -82,11 +80,14 @@ const splitAndCalculate = require('./splitAndCalculate');
 const spreadModifiers = require('./spreadModifiers');
 const validateCreditModifiersTotal = require('./validateCreditModifiersTotal');
 const validateFixedModifiersTotal = require('./validateFixedModifiersTotal');
-const markModifiersAsLocked = require('./markModifiersAsLocked');
 const removeModifiers = require('./removeModifiers');
 const addModifiers = require('./addModifiers');
 const createSuborder = require('./createSuborder');
 const getSuborder = require('./getSuborder');
+const manualSplit = require('./manualSplit');
+const manualSplitByQuantity = require('./manualSplitByQuantity');
+const applyPayment = require('./applyPayment');
+const getBalance = require('./getBalance');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -156,9 +157,6 @@ const orderActions = (deps = {}) => {
     getCustomerSubscriptions: getCustomerSubscriptions(innerDeps),
     getCustomerSubscriptionsByItem: getCustomerSubscriptionsByItem(innerDeps),
     hasRemainingSubscription: hasRemainingSubscription(innerDeps),
-    removeModifiersWithPaymentMethods:
-      removeModifiersWithPaymentMethods(innerDeps),
-    removeModifiersWithPaymentTypes: removeModifiersWithPaymentTypes(innerDeps),
     hasItem: hasItem(innerDeps),
     getNumberOfItems: getNumberOfItems(innerDeps),
     isOpen: isOpen(innerDeps),
@@ -181,11 +179,14 @@ const orderActions = (deps = {}) => {
     spreadModifiers: spreadModifiers(innerDeps),
     validateCreditModifiersTotal: validateCreditModifiersTotal(innerDeps),
     validateFixedModifiersTotal: validateFixedModifiersTotal(innerDeps),
-    markModifiersAsLocked: markModifiersAsLocked(innerDeps),
     removeModifiers: removeModifiers(innerDeps),
     addModifiers: addModifiers(innerDeps),
     createSuborder: createSuborder(innerDeps),
     getSuborder: getSuborder(innerDeps),
+    manualSplit: manualSplit(innerDeps),
+    manualSplitByQuantity: manualSplitByQuantity(innerDeps),
+    applyPayment: applyPayment(innerDeps),
+    getOrdersBalance: getOrdersBalance(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/manualSplit.js

@@ -0,0 +1,34 @@
+module.exports = ({ actions }) =>
+  function manualSplit(
+    { orderIndex, itemIndex },
+    destinationIndex,
+    currentOrder,
+    subOrders,
+    itemId,
+    splitQuantity
+  ) {
+    let _subOrders = subOrders;
+
+    if (
+      orderIndex == null ||
+      itemIndex == null ||
+      subOrders == null ||
+      destinationIndex == null
+    )
+      return _subOrders;
+    if (!subOrders[destinationIndex] || !subOrders[orderIndex])
+      return _subOrders;
+    if (splitQuantity) {
+      _subOrders = actions.manualSplitByQuantity(
+        { orderIndex, itemIndex },
+        destinationIndex,
+        currentOrder,
+        subOrders,
+        itemId
+      );
+    } else {
+      const item = _subOrders[orderIndex].items.splice(itemIndex, 1)[0];
+      if (item) _subOrders[destinationIndex].items.unshift(item);
+    }
+    return _subOrders.map(subOrder => actions.calculate(subOrder));
+  };

package/lib/order/manualSplitByQuantity.js

@@ -0,0 +1,50 @@
+module.exports = () =>
+  function splitByQuantity(
+    { orderIndex, itemIndex },
+    destinationIndex,
+    currentOrder,
+    subOrders,
+    itemId
+  ) {
+    const _subOrders = subOrders;
+    const currentItem = currentOrder.items.find(item => item._id === itemId);
+    const currentSuborder = subOrders[Number(orderIndex)];
+    const currentSuborderItem = (currentSuborder.items || []).find(
+      item => item._id === itemId
+    );
+    const destinationSuborder = subOrders[Number(destinationIndex)];
+    let destinationItem = (destinationSuborder.items || []).find(
+      item => item._id === itemId
+    );
+    if (orderIndex !== destinationIndex) {
+      for (let i = 0; i <= subOrders.length; i += 1) {
+        if (i === orderIndex) {
+          if (currentSuborderItem && currentSuborder && currentSuborder.items) {
+            // react breaks if I don't create a clone to reassign the quantity
+            const _currentSuborderItem = { ...currentSuborderItem };
+            _currentSuborderItem.quantity =
+              Number(_currentSuborderItem.quantity) - 1;
+            currentSuborder.items[Number(itemIndex)] = _currentSuborderItem;
+            if (Number(_currentSuborderItem.quantity) <= 0) {
+              currentSuborder.items.splice(Number(itemIndex), 1);
+            }
+            _subOrders[Number(orderIndex)] = currentSuborder;
+          }
+        }
+
+        if (i === destinationIndex) {
+          // case 1: if the suborder has no items
+          if (!destinationItem) {
+            destinationItem = { ...currentItem, quantity: 1 };
+            destinationSuborder.items =
+              destinationSuborder.items.concat(destinationItem);
+          } else {
+            // case 2: if the suborder has items
+            destinationItem.quantity = Number(destinationItem.quantity) + 1;
+          }
+          _subOrders[Number(destinationIndex)] = destinationSuborder;
+        }
+      }
+    }
+    return _subOrders;
+  };

package/lib/store/pickEndDate.js

@@ -46,8 +46,6 @@ module.exports = ({ settings, _, moment }) => {
     /**
      * setting the hour and minute so we can compare with closedDays
      */
-    if (hour !== undefined) endDateTZ.set('hour', hour);
-    if (minute !== undefined) endDateTZ.set('minute', minute);
     closedDays.forEach(closed => {
       const closedDay = moment(closed.date);
       closedDay.set('hour', hour);
@@ -56,6 +54,8 @@ module.exports = ({ settings, _, moment }) => {
         endDateTZ.add(1, 'days');
       }
     });
+    if (hour !== undefined) endDateTZ.set('hour', hour);
+    if (minute !== undefined) endDateTZ.set('minute', minute);
 
     return moment.utc(endDateTZ).format();
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.44",
+  "version": "1.0.46",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -12,8 +12,11 @@
   "main": "index.js",
   "scripts": {
     "test": "jest --runInBand --detectOpenHandles --logHeapUsage --verbose --forceExit ./__TEST__",
-    "test:me": "jest --runInBand --detectOpenHandles --logHeapUsage --verbose --forceExit",
-    "lint": "eslint --quiet --fix lib/ __TEST__/"
+    "test:me": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/order-payment-modifier.test.js",
+    "test:order": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/order.test.js",
+    "test:validateConditions": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/validateConditionsCalculate.test.js",
+    "test:hasModifier": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/modifier/hasModifier.test.js",
+    "lint": "eslint --quiet lib/"
   },
   "publishConfig": {
     "access": "public"
@@ -36,5 +39,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "9237aef8561cbdf9c29150a0915cf55ff54f3c80"
+  "gitHead": "e048578555dc3d2147bbc4e5b4e0d55809261dcc"
 }

package/lib/item/getBalanceToPay.js

@@ -1,12 +0,0 @@
-module.exports = ({ utils, actions }) =>
-  function getBalanceToPay({ orderItems = [] }) {
-    const total = orderItems.reduce(
-      (t, item) => utils.math.add(actions.getTotal(item), t),
-      0
-    );
-    const totalPaid = orderItems.reduce(
-      (t, item) => utils.math.add(t, item && item.totalPaid),
-      0
-    );
-    return utils.math.toDecimalPlaces(utils.math.sub(total, totalPaid));
-  };