@darkpos/pricing 1.0.44 → 1.0.45

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/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/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.45",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -12,8 +12,10 @@
   "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",
+    "lint": "eslint --quiet lib/"
   },
   "publishConfig": {
     "access": "public"
@@ -36,5 +38,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "9237aef8561cbdf9c29150a0915cf55ff54f3c80"
+  "gitHead": "3bfaa3655ef26d0dc0fb60bdc40caee1e3693ccb"
 }

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));
-  };

package/lib/item/getTotals.js

@@ -1,40 +0,0 @@
-/* eslint-disable no-restricted-syntax */
-
-module.exports = ({ utils }) => {
-  const { math } = utils;
-  return function getTotals(items) {
-    let subTotals = {};
-    let subTotal = 0;
-
-    for (const item of items) {
-      subTotal = math.add(subTotal, item.subTotals._actual);
-      const keys = Object.keys(item.subTotals).filter(
-        key => !key.includes('_')
-      );
-      for (const key of keys) {
-        subTotals[key] = math.add(subTotals[key] || 0, item.subTotals[key]);
-      }
-    }
-
-    const total = math.toDecimalPlaces(
-      Object.keys(subTotals).reduce(
-        (acc, key) => math.add(acc, subTotals[key]),
-        subTotal
-      )
-    );
-
-    subTotals = Object.keys(subTotals).reduce(
-      (acc, key) => ({
-        ...acc,
-        [key]: math.toDecimalPlaces(subTotals[key]),
-      }),
-      {}
-    );
-
-    return {
-      subTotals,
-      subTotal,
-      total,
-    };
-  };
-};

package/lib/item/markModifiersAsLocked.js

@@ -1,13 +0,0 @@
-module.exports = () =>
-  function markModifiersAsLocked({ item, modifierIds }) {
-    if (!item || !Array.isArray(item.modifiers)) return {};
-
-    return {
-      ...item,
-      modifiers: item.modifiers.map(mod =>
-        modifierIds.includes(mod._parentId || mod._id)
-          ? { ...mod, locked: true }
-          : mod
-      ),
-    };
-  };

package/lib/modifier/createPaymentModifier.js

@@ -1,12 +0,0 @@
-module.exports = ({ actions }) =>
-  function createPaymentModifier({
-    modifier = {},
-    items = [],
-    locked = false,
-  }) {
-    return {
-      ...actions.duplicate(modifier),
-      items,
-      locked,
-    };
-  };

package/lib/modifier/getLockedModifiers.js

@@ -1,5 +0,0 @@
-module.exports = () =>
-  function getLockedModifiers(modifiers = []) {
-    if (!Array.isArray(modifiers)) return [];
-    return modifiers.filter(modifier => modifier.locked);
-  };

package/lib/order/markModifiersAsLocked.js

@@ -1,14 +0,0 @@
-module.exports = ({ itemActions }) =>
-  function markModifiersAsLocked({ order, modifierIds }) {
-    if (!order || !Array.isArray(order.modifiers)) return {};
-
-    return {
-      ...order,
-      modifiers: order.modifiers.map(mod =>
-        modifierIds.includes(mod._id) ? { ...mod, locked: true } : mod
-      ),
-      items: (order.items || []).map(item =>
-        itemActions.markModifiersAsLocked({ item, modifierIds })
-      ),
-    };
-  };

package/lib/order/removeModifiersWithPaymentMethods.js

@@ -1,28 +0,0 @@
-module.exports = () => {
-  const hasPaymentMethods = modifier =>
-    modifier.conditions &&
-    modifier.conditions.some(condition => condition.key === 'paymentMethods');
-
-  return function removeModifiersWithPaymentMethods({
-    order,
-    applyItems = false,
-  }) {
-    if (!order || !Array.isArray(order.modifiers)) return order;
-
-    const newOrder = { ...order };
-    newOrder.modifiers = order.modifiers.filter(
-      each => !hasPaymentMethods(each)
-    );
-
-    if (applyItems && Array.isArray(order.items)) {
-      newOrder.items = order.items.map(item => {
-        if (!Array.isArray(item.modifiers)) return item;
-        return {
-          ...item,
-          modifiers: item.modifiers.filter(each => !hasPaymentMethods(each)),
-        };
-      });
-    }
-    return newOrder;
-  };
-};

package/lib/order/removeModifiersWithPaymentTypes.js

@@ -1,26 +0,0 @@
-module.exports = () => {
-  const hasPaymentTypes = modifier =>
-    modifier.conditions &&
-    modifier.conditions.some(condition => condition.key === 'paymentMethods');
-
-  return function removeModifiersWithPaymentTypes({
-    order,
-    applyItems = false,
-  }) {
-    if (!order || !Array.isArray(order.modifiers)) return order;
-
-    const newOrder = { ...order };
-    newOrder.modifiers = order.modifiers.filter(each => !hasPaymentTypes(each));
-
-    if (applyItems && Array.isArray(order.items)) {
-      newOrder.items = order.items.map(item => {
-        if (!Array.isArray(item.modifiers)) return item;
-        return {
-          ...item,
-          modifiers: item.modifiers.filter(each => !hasPaymentTypes(each)),
-        };
-      });
-    }
-    return newOrder;
-  };
-};