@darkpos/pricing 1.0.21 → 1.0.23

package/lib/item/addIndirectModifier.js

@@ -25,7 +25,9 @@ module.exports = ({ utils, modifierActions }) => {
       );
     }, 0);
 
-    // check validation
+    if (modifier.compute.type === 'percentage' && modifier.type !== 'credit')
+      return itemsModifiers;
+
     if (math.abs(totalDistributed) !== math.abs(orderModifierTotal)) {
       const difference = math.sub(orderModifierTotal, totalDistributed);
       const selectedItem = items.find(

package/lib/item/calculate.js

@@ -66,17 +66,26 @@ module.exports = ({ _, utils, modifierActions }) => {
 
         modifiers.push(_modifier);
         const { type, _computed } = _modifier;
-        let computedAmount = modifierActions.isIgnoreQuantity(_modifier)
-          ? _computed.amount
-          : math.mul(_computed.amount, quantity);
+
+        const computedAmountCalc = math.mul(_computed.amount, quantity);
+        const computedPriceCalc = math.mul(computedPrice * quantity);
+
+        let computedAmount =
+          _modifier.compute.type === 'percentage' ||
+          modifierActions.isIgnoreQuantity(_modifier) ||
+          math.gt(math.abs(computedAmountCalc), computedPriceCalc)
+            ? _computed.amount
+            : computedAmountCalc;
+
         // subscription modifiers have fixed amount and can't be multiplied by quantity
         if (modifierActions.isSubscription(_modifier))
           computedAmount = _computed.amount;
 
+        prvPrice = math.add(prvPrice, math.div(_computed.amount, quantity));
+        prvSort = sort;
+
         if (included) {
           subTotals._included = math.add(subTotals._included, computedAmount);
-          prvPrice = math.add(prvPrice, computedAmount);
-          prvSort = sort;
         } else {
           subTotals._xincluded = math.add(subTotals._xincluded, computedAmount);
           subTotals[type] = math.add(subTotals[type] || 0, computedAmount);
@@ -89,7 +98,9 @@ module.exports = ({ _, utils, modifierActions }) => {
 
     subTotals._actual = math.add(subTotals._simple, subTotals._included);
 
-    const total = math.add(subTotals._actual, subTotals._xincluded);
+    const total = math.toDecimalPlaces(
+      math.add(subTotals._actual, subTotals._xincluded)
+    );
 
     return {
       ...item,

package/lib/item/getTotals.js

@@ -16,15 +16,17 @@ module.exports = ({ utils }) => {
       }
     }
 
-    const total = Object.keys(subTotals).reduce(
-      (acc, key) => math.add(acc, subTotals[key]),
-      subTotal
+    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]: subTotals[key],
+        [key]: math.toDecimalPlaces(subTotals[key]),
       }),
       {}
     );

package/lib/modifier/calculate.js

@@ -1,13 +1,13 @@
 /**
  * Get calculated modifier
  */
- module.exports = ({ _, constants, utils, localization, actions }) => {
+module.exports = ({ _, constants, utils, localization, actions }) => {
   const { math } = utils;
   const { Modifier } = constants;
 
   return function calculate(
     modifier = {},
-    options = { price: 0, skip: false }
+    options = { price: 0, quantity: 0, skip: false }
   ) {
     const { name, compute } = modifier;
     const { type, action, amount = 0 } = compute || {};
@@ -15,8 +15,16 @@
       amount: 0,
       description: '',
     };
-    const maxAmount = actions.getProperty(modifier, 'maxAmount');
+
+    const maxAmountProp = actions.getProperty(modifier, 'maxAmount');
+
     if (!options.skip) {
+      const maxAmountCalc = math.mul(options.price, options.quantity);
+
+      const maxAmount = maxAmountProp
+        ? math.min(maxAmountProp, maxAmountCalc)
+        : maxAmountCalc;
+
       const multiplier = action === Modifier.Compute.Actions.SUBTRACT ? -1 : 1;
 
       if (type === Modifier.Compute.Types.FIXED)
@@ -24,15 +32,16 @@
 
       if (type === Modifier.Compute.Types.PERCENTAGE)
         _computed.amount = math.div(
-          math.mul(multiplier, options.price, amount),
+          math.mul(multiplier, options.price, options.quantity, amount),
           100
         );
 
       if (!type || action === Modifier.Compute.Actions.OVERRIDE)
         _computed.amount = 0;
 
-      if (maxAmount && math.gt(math.abs(_computed.amount), maxAmount))
-        _computed.amount = maxAmount;
+      if (math.gt(math.abs(_computed.amount), maxAmount)) {
+        _computed.amount = maxAmount * multiplier;
+      }
     }
 
     const localAmount = localization.formatAmount(_computed.amount);

package/lib/modifier/createIndirectModifier.js

@@ -16,9 +16,14 @@ module.exports = ({ _, utils, constants, actions }) => {
     let modifierAmount = amount;
 
     if (type === Modifier.Compute.Types.PERCENTAGE) {
-      const modifierAmountByPercentage = math.div(
-        math.mul(options.orderTotal, amount),
-        100
+      const modifierAmountByPercentage = math.toDecimalPlaces(
+        math.div(
+          math.mul(
+            modifier.type === 'credit' ? options.orderTotal : options.itemTotal,
+            amount
+          ),
+          100
+        )
       );
       modifierAmount =
         maxAmount !== null && modifierAmountByPercentage > maxAmount
@@ -26,14 +31,20 @@ module.exports = ({ _, utils, constants, actions }) => {
           : modifierAmountByPercentage;
     }
 
-    let amountToApply = 0;
+    let amountToApply = modifierAmount;
 
-    if (!math.isZero(options.orderTotal))
-      amountToApply = math.div(
-        math.mul(modifierAmount, options.itemTotal),
-        options.orderTotal,
-        options.itemQuantity
+    if (
+      !math.isZero(options.orderTotal) &&
+      (type !== Modifier.Compute.Types.PERCENTAGE || modifier.type === 'credit')
+    ) {
+      amountToApply = math.toDecimalPlaces(
+        math.div(
+          math.mul(modifierAmount, options.itemTotal),
+          options.orderTotal,
+          options.itemQuantity
+        )
       );
+    }
 
     const modifierToAdd = actions.create({
       ..._.cloneDeep(modifier),
@@ -43,6 +54,12 @@ module.exports = ({ _, utils, constants, actions }) => {
         amount: amountToApply,
         action: compute.action || Modifier.Compute.Actions.SUBTRACT,
       },
+      properties: {
+        ignoreQuantity:
+          (modifier.properties && modifier.properties.ignoreQuantity) ||
+          type === Modifier.Compute.Types.PERCENTAGE,
+        ...(modifier.properties || {}),
+      },
     });
     if (maxAmount !== null) delete modifierToAdd.properties.maxAmount;
 

package/lib/modifier/getModifiersByMaxSort.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function getModifiersByMaxSort(modifiers, maxSort) {
+    if (!Array.isArray(modifiers) || !Number.isInteger(maxSort))
+      return modifiers;
+
+    return modifiers.filter(
+      mod => !mod.properties || mod.properties.sort < maxSort
+    );
+  };

package/lib/modifier/getSplittedModifiers.js

@@ -7,9 +7,11 @@ module.exports = ({ utils }) => {
     totalSplitedOrder,
   }) =>
     totalOriginOrder
-      ? math.div(
-          math.mul(modifierAmount, totalSplitedOrder || 0),
-          totalOriginOrder
+      ? math.toDecimalPlaces(
+          math.div(
+            math.mul(modifierAmount, totalSplitedOrder || 0),
+            totalOriginOrder
+          )
         )
       : 0;
 

package/lib/modifier/index.js

@@ -45,6 +45,7 @@ const getInheritedModifiers = require('./getInheritedModifiers');
 const getLaundryModifiers = require('./getLaundryModifiers');
 const getMatchTagsModifiers = require('./getMatchTagsModifiers');
 const getModifierIndex = require('./getModifierIndex');
+const getModifiersByMaxSort = require('./getModifiersByMaxSort');
 const getPreferences = require('./getPreferences');
 const getPromotionModifiers = require('./getPromotionModifiers');
 const getPromptMessage = require('./getPromptMessage');
@@ -180,6 +181,7 @@ const modifierActions = (deps = {}) => {
     getLaundryModifiers: getLaundryModifiers(innerDeps),
     getMatchTagsModifiers: getMatchTagsModifiers(innerDeps),
     getModifierIndex: getModifierIndex(innerDeps),
+    getModifiersByMaxSort: getModifiersByMaxSort(innerDeps),
     getPreferences: getPreferences(innerDeps),
     getPromotionModifiers: getPromotionModifiers(innerDeps),
     getPromptMessage: getPromptMessage(innerDeps),

package/lib/modifier/sort.js

@@ -1,24 +1,25 @@
 /* eslint-disable no-prototype-builtins */
-module.exports = () => {
+module.exports = ({ actions }) => {
   function compareValues(key, order = 'asc') {
     return function innerSort(a, b) {
       // property doesn't exist on either object
-      if (
-        !a.properties ||
-        !a.properties.hasOwnProperty(key) ||
-        !b.properties ||
-        !b.properties.hasOwnProperty(key)
-      )
+      const aVal = actions.getProperty(a, key);
+      const bVal = actions.getProperty(b, key);
+
+      if (aVal == null && bVal === null) {
         return 0;
+      }
+
+      if (aVal == null) {
+        return -1;
+      }
+
+      if (bVal === null) {
+        return 1;
+      }
 
-      const varA =
-        typeof a.properties[key] === 'string'
-          ? a.properties[key].toUpperCase()
-          : a.properties[key];
-      const varB =
-        typeof b.properties[key] === 'string'
-          ? b.properties[key].toUpperCase()
-          : b.properties[key];
+      const varA = typeof aVal === 'string' ? aVal.toUpperCase() : aVal;
+      const varB = typeof bVal === 'string' ? bVal.toUpperCase() : bVal;
 
       let comparison = 0;
       if (varA > varB) comparison = 1;

package/lib/order/calculate.js

@@ -11,10 +11,12 @@ module.exports = ({ _, itemActions, modifierActions }) =>
     if (!items.length)
       return { ...order, subTotals: {}, subTotal: 0, total: 0 };
 
-    const orderModifiers = modifierActions.removeLocked(order.modifiers);
+    const sortedOrderModifiers = modifierActions.sort(
+      modifierActions.removeLocked(order.modifiers)
+    );
 
     let itemsWNIM = items.map(item =>
-      itemActions.removeModifiers({ item, modifiers: orderModifiers })
+      itemActions.removeModifiers({ item, modifiers: sortedOrderModifiers })
     );
 
     itemsWNIM = itemActions.calculate(itemsWNIM);
@@ -25,25 +27,39 @@ module.exports = ({ _, itemActions, modifierActions }) =>
       items: itemsWNIM,
     };
 
-    if (!orderModifiers.length) return newOrder;
+    if (!sortedOrderModifiers.length) return newOrder;
 
-    const newItems = itemsWNIM || items;
-    let itemsWIM = _.cloneDeep(newItems);
+    let tempItems = itemsWNIM || items;
+    let itemsWIM = _.cloneDeep(tempItems);
+    let prvSort = null;
 
     let computedTotal = newOrder.total;
 
-    for (const modifier of orderModifiers) {
+    for (const modifier of sortedOrderModifiers) {
       const isCredit = modifierActions.isCredit(modifier);
-      let tempItems = newItems;
+      const sort = modifierActions.getProperty(modifier, 'sort');
+
+      if (prvSort !== sort) {
+        if (sort) {
+          tempItems = itemsWIM.map(item => ({
+            ...item,
+            modifiers: modifierActions.getModifiersByMaxSort(
+              item.modifiers,
+              modifier.properties.sort
+            ),
+          }));
+        } else {
+          tempItems = itemsWIM;
+        }
+        tempItems = itemActions.calculate(tempItems);
+      }
 
       if (isCredit) {
         const calculatedItemWIM = itemActions.calculate(itemsWIM);
         computedTotal = itemActions.getTotals(calculatedItemWIM).total;
       }
 
-      const hasItems = modifierActions.hasItems({ modifier });
-
-      if (hasItems) {
+      if (modifierActions.hasItems({ modifier })) {
         tempItems = itemActions.getItems(tempItems, modifier.items);
       }
 
@@ -54,8 +70,6 @@ module.exports = ({ _, itemActions, modifierActions }) =>
         })
       );
 
-      tempItems = itemActions.calculate(tempItems);
-
       computedTotal = itemActions.getTotals(tempItems).total;
 
       const itemsModifiers = itemActions.addIndirectModifier({
@@ -71,6 +85,7 @@ module.exports = ({ _, itemActions, modifierActions }) =>
           Boolean
         ),
       }));
+      prvSort = sort;
     }
 
     const calculatedItemWIM = itemActions.calculate(itemsWIM);

package/lib/order/getTotals.js

@@ -17,6 +17,7 @@ module.exports = ({ utils }) => {
                 orderSubTotals[key]
               );
           }
+
           return {
             total: math.add(acc.total, order.total),
             subTotals,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -19,7 +19,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@darkpos/utils": "1.0.8",
+    "@darkpos/utils": "1.0.9",
     "lodash": "^4.17.21",
     "moment-timezone": "^0.5.34"
   },
@@ -36,5 +36,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "30595eb4b38240679c45e5eff7ac875719e9dcd0"
+  "gitHead": "6648705882ec8351463ba823c213cf7c198129ce"
 }