@darkpos/pricing 1.0.52 → 1.0.54

package/lib/item/calculate.js

@@ -1,5 +1,3 @@
-const { getComputeModField } = require('../modifier/utils');
-
 /* eslint-disable no-restricted-syntax */
 module.exports = ({ _, utils, actions, modifierActions }) => {
   const { math } = utils;
@@ -94,6 +92,9 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         })
       );
 
+    let computedPrice = price;
+    let total = math.mul(computedPrice, quantity);
+
     if (modifiersToCompute.length || paymentModifiersToCompute.length) {
       // sort modifiers based on sort
       const sortedModifiers = modifierActions.sort([
@@ -101,7 +102,6 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         ...paymentModifiersToCompute,
       ]);
 
-      let computedPrice = price;
       let prvPrice = 0;
       let prvSort;
 
@@ -138,6 +138,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
             price: computedPrice,
             quantity,
             basePrice: actions.getBasePrice(item),
+            maxDiscountAmount: total,
           }
         );
 
@@ -150,29 +151,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
 
         const { type, _computed } = _modifier;
 
-        const computedAmountCalc = math.mul(_computed.amount, quantity);
-        const computedPriceCalc = math.mul(computedPrice * quantity);
-
-        // adding this computeField because now the compute from a modifier can be null
-        const computeField = getComputeModField(_modifier);
-
-        const isPercentage = computeField.type === 'percentage';
-        const isIgnoreQuantity = modifierActions.isIgnoreQuantity(_modifier);
-        const isNotFixedAddAndAmountGtPrice =
-          !modifierActions.isFixedAdd(_modifier) &&
-          math.gt(math.abs(computedAmountCalc), computedPriceCalc);
-
-        const isAmountOverrideAndNotMultiplier =
-          modifierActions.isAmountOverride(_modifier) &&
-          !modifierActions.isMultiplier(_modifier);
-
-        let computedAmount =
-          isPercentage ||
-          isIgnoreQuantity ||
-          isNotFixedAddAndAmountGtPrice ||
-          isAmountOverrideAndNotMultiplier
-            ? _computed.amount
-            : computedAmountCalc;
+        let computedAmount = _computed.amount;
 
         // subscription modifiers have fixed amount and can't be multiplied by quantity
         if (modifierActions.isSubscription(_modifier))
@@ -190,12 +169,15 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         if (direct)
           subTotals._direct = math.add(subTotals._direct, computedAmount);
         else subTotals._xdirect = math.add(subTotals._xdirect, computedAmount);
+
+        subTotals._actual = math.add(subTotals._simple, subTotals._included);
+        total = actions.getTotal({ subTotals });
       }
     }
 
     subTotals._actual = math.add(subTotals._simple, subTotals._included);
 
-    const total = actions.getTotal({ subTotals });
+    total = actions.getTotal({ subTotals });
 
     return {
       ...item,

package/lib/modifier/calculate.js

@@ -14,12 +14,14 @@ module.exports = ({ _, constants, utils, localization, actions }) => {
     const modifier = _modifier;
     const { name } = modifier;
     const compute = getComputeModField(modifier);
-    const { type, action, amount = 0 } = compute;
+    const { type, amount: computeAmount = 0 } = compute;
     const _computed = {
       amount: 0,
       description: '',
     };
 
+    const amount = computeAmount;
+
     const maxAmountProp = actions.getProperty(modifier, 'maxAmount');
 
     if (!options.skip) {
@@ -32,22 +34,41 @@ module.exports = ({ _, constants, utils, localization, actions }) => {
         ? math.min(maxAmountProp, maxAmountCalc)
         : maxAmountCalc;
 
-      const multiplier = action === Modifier.Compute.Actions.SUBTRACT ? -1 : 1;
+      const multiplier = actions.isSubtract(_modifier) ? -1 : 1;
 
-      if (type === Modifier.Compute.Types.FIXED)
+      if (type === Modifier.Compute.Types.FIXED) {
         _computed.amount = math.mul(multiplier, amount);
+      }
 
-      if (type === Modifier.Compute.Types.PERCENTAGE)
+      if (type === Modifier.Compute.Types.PERCENTAGE) {
         _computed.amount = math.div(
-          math.mul(multiplier, options.price, options.quantity, amount),
+          math.mul(multiplier, options.price, amount),
           100
         );
+      }
 
       if (!type) _computed.amount = 0;
 
       if (math.gt(math.abs(_computed.amount), maxAmount)) {
         _computed.amount = maxAmount * multiplier;
       }
+
+      if (
+        (!actions.isOverride(_modifier) &&
+          actions.isQuantityMultiplier(_modifier)) ||
+        (actions.isAmountOverride(_modifier) && actions.isMultiplier(_modifier))
+      ) {
+        _computed.amount = math.mul(_computed.amount, options.quantity);
+      }
+
+      if (
+        actions.isSubtract(_modifier) &&
+        typeof _computed.amount === 'number' &&
+        typeof options.maxDiscountAmount === 'number' &&
+        math.gt(math.abs(_computed.amount), options.maxDiscountAmount)
+      ) {
+        _computed.amount = math.mul(options.maxDiscountAmount, -1);
+      }
     }
 
     const localAmount =
@@ -71,7 +92,7 @@ module.exports = ({ _, constants, utils, localization, actions }) => {
 
     if (actions.isAmountOverride(modifier) && isMultiplier) {
       _computed.description = `${name} (${localization.formatAmount(
-        math.mul(_computed.amount, options.quantity)
+        _computed.amount
       )})`;
     }
 

package/lib/modifier/createFeeModifier.js

@@ -19,7 +19,7 @@ module.exports = ({ constants, actions, localization }) => {
       type: Modifier.Types.FEE,
       name: `${name} ${Modifier.Types.FEE}`,
       properties: {
-        ignoreQuantity: true,
+        isQuantityMultiplier: false,
         ...properties,
       },
       ...rest,

package/lib/modifier/createIndirectModifier.js

@@ -36,10 +36,9 @@ module.exports = ({ _, utils, constants, actions }) => {
       !math.isZero(options.orderTotal) &&
       (type !== Modifier.Compute.Types.PERCENTAGE || modifier.type === 'credit')
     ) {
-      const modififierQuantity =
-        modifier.properties && modifier.properties.ignoreQuantity
-          ? 1
-          : options.itemQuantity;
+      const modififierQuantity = !actions.isQuantityMultiplier(modifier)
+        ? 1
+        : options.itemQuantity;
 
       amountToApply = math.div(
         math.mul(modifierAmount, options.itemTotal),
@@ -57,10 +56,10 @@ module.exports = ({ _, utils, constants, actions }) => {
         action: compute.action || Modifier.Compute.Actions.SUBTRACT,
       },
       properties: {
-        ignoreQuantity:
-          (modifier.properties && modifier.properties.ignoreQuantity) ||
-          type === Modifier.Compute.Types.PERCENTAGE,
         ...(modifier.properties || {}),
+        isQuantityMultiplier:
+          type !== Modifier.Compute.Types.PERCENTAGE &&
+          actions.isQuantityMultiplier(modifier),
       },
     });
     if (maxAmount !== null) delete modifierToAdd.properties.maxAmount;

package/lib/modifier/index.js

@@ -103,7 +103,6 @@ const isAmountOverride = require('./isAmountOverride');
 const isValid = require('./isValid');
 const isDiscount = require('./isDiscount');
 const isHidden = require('./isHidden');
-const isIgnoreQuantity = require('./isIgnoreQuantity');
 const isGratuity = require('./isGratuity');
 const isPaymentMethodModifier = require('./isPaymentMethodModifier');
 const isPaymentTypeModifier = require('./isPaymentTypeModifier');
@@ -148,6 +147,8 @@ const isExtractCalculatedValue = require('./isExtractCalculatedValue');
 const getPriceWithoutModifier = require('./getPriceWithoutModifier');
 const isGroup = require('./isGroup');
 const isOptionsSelectedOverride = require('./isOptionsSelectedOverride');
+const isFixedSubtract = require('./isFixedSubtract');
+const isQuantityMultiplier = require('./isQuantityMultiplier');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -262,7 +263,6 @@ const modifierActions = (deps = {}) => {
     isValid: isValid(innerDeps),
     isDiscount: isDiscount(innerDeps),
     isHidden: isHidden(innerDeps),
-    isIgnoreQuantity: isIgnoreQuantity(innerDeps),
     isGratuity: isGratuity(innerDeps),
     isPaymentMethodModifier: isPaymentMethodModifier(innerDeps),
     isPaymentTypeModifier: isPaymentTypeModifier(innerDeps),
@@ -309,6 +309,8 @@ const modifierActions = (deps = {}) => {
     getPriceWithoutModifier: getPriceWithoutModifier(innerDeps),
     isGroup: isGroup(innerDeps),
     isOptionsSelectedOverride: isOptionsSelectedOverride(innerDeps),
+    isFixedSubtract: isFixedSubtract(innerDeps),
+    isQuantityMultiplier: isQuantityMultiplier(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isFixedSubtract.js

@@ -0,0 +1,4 @@
+module.exports = ({ actions }) =>
+  function isFixedSubtract(modifier) {
+    return actions.isSubtract(modifier) && actions.isFixed(modifier);
+  };

package/lib/modifier/isQuantityMultiplier.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function isQuantityMultiplier(modifier) {
+    if (!modifier || !modifier.properties) return false;
+    return !!modifier.properties.isQuantityMultiplier;
+  };

package/lib/order/calculate.js

@@ -40,89 +40,92 @@ module.exports = ({
       ),
     });
 
+    let calculatedItems = itemsWNIM || [];
+
     const newOrder = {
       ...order,
       ...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;
-
-    let computedTotal = newOrder.total;
-
-    for (const modifier of sortedOrderModifiers) {
-      const isCredit = modifierActions.isCredit(modifier);
-      const sort = modifierActions.getProperty(modifier, 'sort');
+    if (sortedOrderModifiers.length > 0) {
+      itemsWNIM = itemActions.calculate(itemsWNIM, {});
+
+      let tempItems = itemsWNIM || items;
+      let itemsWIM = _.cloneDeep(tempItems);
+      let prvSort = null;
+
+      let computedTotal = newOrder.total;
+
+      for (const modifier of sortedOrderModifiers) {
+        const isCredit = modifierActions.isCredit(modifier);
+        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, options);
+        }
 
-      if (prvSort !== sort) {
-        if (sort) {
-          tempItems = itemsWIM.map(item => ({
-            ...item,
-            modifiers: modifierActions.getModifiersByMaxSort(
-              item.modifiers,
-              modifier.properties.sort
-            ),
-          }));
-        } else {
-          tempItems = itemsWIM;
+        if (isCredit) {
+          const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
+          computedTotal = itemActions.getItemsTotals(calculatedItemWIM).total;
         }
-        tempItems = itemActions.calculate(tempItems, options);
-      }
 
-      if (isCredit) {
-        const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
-        computedTotal = itemActions.getItemsTotals(calculatedItemWIM).total;
-      }
+        if (modifierActions.hasItems({ modifier })) {
+          tempItems = itemActions.getItems(tempItems, modifier.items);
+        }
 
-      if (modifierActions.hasItems({ modifier })) {
-        tempItems = itemActions.getItems(tempItems, modifier.items);
+        computedTotal = itemActions.getItemsTotals(tempItems).total;
+
+        const itemsModifiers = itemActions.addIndirectModifier({
+          orderTotal: computedTotal,
+          items: tempItems,
+          modifier,
+        });
+
+        // adding the modifiers to items
+        itemsWIM = itemsWIM.map(item => ({
+          ...item,
+          modifiers: [
+            ...(item.modifiers || []),
+            itemsModifiers[item._id],
+          ].filter(Boolean),
+        }));
+        prvSort = sort;
       }
 
-      computedTotal = itemActions.getItemsTotals(tempItems).total;
-
-      const itemsModifiers = itemActions.addIndirectModifier({
-        orderTotal: computedTotal,
-        items: tempItems,
-        modifier,
-      });
-
-      // adding the modifiers to items
-      itemsWIM = itemsWIM.map(item => ({
-        ...item,
-        modifiers: [...(item.modifiers || []), itemsModifiers[item._id]].filter(
-          Boolean
-        ),
-      }));
-      prvSort = sort;
+      calculatedItems = itemActions.calculate(itemsWIM, options);
     }
 
-    const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
-
     const addToItemTotal = difference => {
-      if (difference > 0 && calculatedItemWIM.length) {
-        calculatedItemWIM[0].total = utils.math.toDecimalPlaces(
-          utils.math.add(calculatedItemWIM[0].total, difference)
+      if (difference > 0 && calculatedItems.length) {
+        calculatedItems[0].total = utils.math.toDecimalPlaces(
+          utils.math.add(calculatedItems[0].total, difference)
         );
       }
     };
 
-    if (calculatedItemWIM.length > 1) {
+    if (calculatedItems.length > 1) {
       const difference = itemActions.getTotalsDifference({
-        items: calculatedItemWIM,
+        items: calculatedItems,
       });
 
       addToItemTotal(difference);
     }
 
-    if (storeActions.isNeareastMultiple() && calculatedItemWIM.length > 0) {
+    if (storeActions.isNeareastMultiple() && calculatedItems.length > 0) {
       const difference = itemActions.getTotalNeareastDifference({
-        items: calculatedItemWIM,
+        items: calculatedItems,
       });
 
       if (difference > 0) addToItemTotal(difference);
@@ -130,7 +133,7 @@ module.exports = ({
 
     return {
       ...order,
-      ...itemActions.getItemsTotals(calculatedItemWIM),
-      items: calculatedItemWIM,
+      ...itemActions.getItemsTotals(calculatedItems),
+      items: calculatedItems,
     };
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.52",
+  "version": "1.0.54",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -19,6 +19,7 @@
     "test:item": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/item.test.js",
     "test:split": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/split.test.js",
     "test:getModifierTags": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/item/getModifierTags.test.js",
+    "test:createIndirectModifier": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/modifier/createIndirectModifier.test.js",
     "lint": "eslint --quiet lib/"
   },
   "publishConfig": {
@@ -42,5 +43,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "43e5d458336e6d49ffbcf8af2a715428364a4df5"
+  "gitHead": "8bba2c9f52f54528ea2d0dece82406ef9fe69cb3"
 }

package/lib/modifier/isIgnoreQuantity.js

@@ -1,5 +0,0 @@
-module.exports = () =>
-  function isIgnoreQuantity(modifier) {
-    if (!modifier || !modifier.properties) return false;
-    return modifier.properties.ignoreQuantity;
-  };