@darkpos/pricing 1.0.112 → 1.0.115

package/lib/item/calculate.js

@@ -4,7 +4,10 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
   //
 
   const calculateOne = (inputItem, opts = {}) => {
-    const item = _.cloneDeep(inputItem);
+    const item = _.cloneDeep({
+      ...inputItem,
+      quantity: math.max(0, Number(inputItem.quantity) || 0),
+    });
     const amountToPay =
       typeof opts.amountToPay === 'number' ? opts.amountToPay : 0;
     const paymentMethod = opts.paymentMethod || null;
@@ -41,11 +44,9 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
     }
 
     const modifiers = [];
-    let { modifiers: itemModifiersPrev = [] } =
-      actions.removeModifiersByQuantity(item);
 
-    itemModifiersPrev = modifierActions.unlockCustomerStatsModifiers({
-      modifiers: itemModifiersPrev,
+    const itemModifiersPrev = modifierActions.unlockCustomerStatsModifiers({
+      modifiers: item.modifiers,
       customer,
     });
 
@@ -175,6 +176,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
           };
           item.price = priceOverride;
           price = priceOverride;
+          computedPrice = priceOverride;
         }
 
         if (modifierActions.isQuantityOverride(modifier)) {

package/lib/item/index.js

@@ -43,7 +43,7 @@ const getTotalsDifference = require('./getTotalsDifference');
 const getTotalNeareastDifference = require('./getTotalNeareastDifference');
 const getNoteTags = require('./getNoteTags');
 const getBasePrice = require('./getBasePrice');
-const removeModifiersByQuantity = require('./removeModifiersByQuantity');
+const validateModifiersByQuantity = require('./validateModifiersByQuantity');
 const getModifiersBySingleValueId = require('./getModifiersBySingleValueId');
 const getLastLocation = require('./getLastLocation');
 const hasAddModifiers = require('./hasAddModifiers');
@@ -126,7 +126,7 @@ const itemActions = (deps = {}) => {
     getTotalNeareastDifference: getTotalNeareastDifference(innerDeps),
     getNoteTags: getNoteTags(innerDeps),
     getBasePrice: getBasePrice(innerDeps),
-    removeModifiersByQuantity: removeModifiersByQuantity(innerDeps),
+    validateModifiersByQuantity: validateModifiersByQuantity(innerDeps),
     getModifiersBySingleValueId: getModifiersBySingleValueId(innerDeps),
     getLastLocation: getLastLocation(innerDeps),
     hasAddModifiers: hasAddModifiers(innerDeps),

package/lib/item/validateModifiers.js

@@ -1,4 +1,4 @@
-module.exports = ({ modifierActions }) =>
+module.exports = ({ modifierActions, actions }) =>
   function validateModifiers({
     item,
     itemModifiers,
@@ -11,7 +11,7 @@ module.exports = ({ modifierActions }) =>
     customer,
   }) {
     const validatedModifiers = [];
-    const firstValidatedModifiers = itemModifiers.map(each =>
+    let firstValidatedModifiers = itemModifiers.map(each =>
       modifierActions.validate(each, {
         item,
         startRequestDate,
@@ -24,20 +24,30 @@ module.exports = ({ modifierActions }) =>
       })
     );
 
+    firstValidatedModifiers = actions.validateModifiersByQuantity({
+      modifiers: firstValidatedModifiers,
+      quantity: item.quantity,
+    });
+
+    const isIdMatch = (mod, modifierId) => {
+      if (typeof mod === 'string') return mod === modifierId;
+      return mod._id === modifierId;
+    };
+
     firstValidatedModifiers.forEach(validModifier => {
       const parentAddModifier = firstValidatedModifiers.find(
         validMod =>
           validMod.addModifiers &&
-          validMod.addModifiers.some(
-            addMod => addMod._id === validModifier.modifierId
+          validMod.addModifiers.some(addMod =>
+            isIdMatch(addMod, validModifier.modifierId)
           )
       );
 
       const parentDelModifier = firstValidatedModifiers.find(
         validMod =>
           validMod.delModifiers &&
-          validMod.delModifiers.some(
-            delMod => delMod._id === validModifier.modifierId
+          validMod.delModifiers.some(delMod =>
+            isIdMatch(delMod, validModifier.modifierId)
           )
       );
 
@@ -53,13 +63,8 @@ module.exports = ({ modifierActions }) =>
         nextValidModifier.conditions.valid;
 
       if (shouldInvalidateAddModifier || shouldInvalidateDelModifier) {
-        nextValidModifier = {
-          ...nextValidModifier,
-          conditions: {
-            ...validModifier.conditions,
-            valid: false,
-          },
-        };
+        nextValidModifier =
+          modifierActions.markModifierAsNotValid(nextValidModifier);
       }
 
       if (

package/lib/item/validateModifiersByQuantity.js

@@ -0,0 +1,32 @@
+module.exports = ({ modifierActions, utils }) =>
+  function validateModifiersByQuantity({ modifiers, quantity }) {
+    if (!modifiers || !Array.isArray(modifiers)) {
+      return [];
+    }
+
+    const modifierCounts = {};
+
+    return modifiers.map(modifier => {
+      if (
+        modifierActions.isPaymentModifier(modifier) ||
+        modifierActions.isCalculatedPaymentModifier(modifier) ||
+        modifierActions.isGroupOfModifiers(modifier) ||
+        !modifier.modifierId ||
+        !modifierActions.isDirect(modifier) ||
+        modifierActions.isUnlimitedItemUse(modifier)
+      )
+        return modifier;
+
+      const count = modifierCounts[modifier.modifierId] || 0;
+
+      const maxApplies = modifierActions.getMaxItemUse(modifier) || 0;
+      const maxQuantity = utils.math.mul(quantity || 0, maxApplies) || quantity;
+
+      if (count < maxQuantity) {
+        modifierCounts[modifier.modifierId] = count + 1;
+        return modifier;
+      }
+
+      return modifierActions.markModifierAsNotValid(modifier);
+    });
+  };

package/lib/modifier/index.js

@@ -177,6 +177,7 @@ const isAutoSplit = require('./isAutoSplit');
 const isKeepRelatedItems = require('./isKeepRelatedItems');
 const isSplitDepartment = require('./isSplitDepartment');
 const isModifierValid = require('./isModifierValid');
+const markModifierAsNotValid = require('./markModifierAsNotValid');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -367,6 +368,7 @@ const modifierActions = (deps = {}) => {
     isKeepRelatedItems: isKeepRelatedItems(innerDeps),
     isSplitDepartment: isSplitDepartment(innerDeps),
     isModifierValid: isModifierValid(innerDeps),
+    markModifierAsNotValid: markModifierAsNotValid(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isAvailableSubscription.js

@@ -14,9 +14,9 @@ module.exports = ({ utils, actions }) => {
     };
 
     if (
-      properties.numberOfUses &&
-      properties.numberOfUsesLimit &&
-      math.gte(properties.numberOfUses, properties.numberOfUsesLimit)
+      properties.uses &&
+      properties.usesLimit &&
+      math.gte(properties.uses, properties.usesLimit)
     )
       return false;
 

package/lib/modifier/markModifierAsNotValid.js

@@ -0,0 +1,10 @@
+module.exports = () =>
+  function markModifierAsNotValid(modifier) {
+    return {
+      ...modifier,
+      conditions: {
+        ...modifier.conditions,
+        valid: false,
+      },
+    };
+  };

package/lib/order/getOrderItemSubscriptions.js

@@ -26,15 +26,15 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     }
 
     const { quantity, price } = orderItem;
-    let numberOfUses = quantity;
+    let uses = quantity;
     if (remaining) {
       const left = remaining - (used || 0);
-      if (quantity > left) numberOfUses = left;
+      if (quantity > left) uses = left;
     }
 
     const modifier = modifierActions.createSubscriptionModifier({
-      amount: math.mul(numberOfUses, price),
-      properties: { subscription: { numberOfUses } },
+      amount: math.mul(uses, price),
+      properties: { subscription: { uses } },
     });
     orderItem.modifiers.push(modifier);
 

package/lib/order/hasRemainingSubscription.js

@@ -1,13 +1,9 @@
 module.exports = ({ actions, modifierActions }) => {
   const getRemaining = (subscriptions, orderId) => {
     const remaining = subscriptions.reduce((total, subscription) => {
-      const {
-        numberOfUsesLimit = 0,
-        numberOfUses = 0,
-        history = {},
-      } = subscription;
+      const { usesLimit = 0, uses = 0, history = {} } = subscription;
       const orderHistory = history[orderId] || 0;
-      return total + numberOfUsesLimit + orderHistory - numberOfUses;
+      return total + usesLimit + orderHistory - uses;
     }, 0);
 
     return remaining;
@@ -27,16 +23,16 @@ module.exports = ({ actions, modifierActions }) => {
       ],
       []
     );
-    const numberOfUses = modifiers.reduce(
+    const uses = modifiers.reduce(
       (sum, each) =>
         sum +
         ((each.properties &&
           each.properties.subscription &&
-          each.properties.subscription.numberOfUses) ||
+          each.properties.subscription.uses) ||
           0),
       0
     );
-    return numberOfUses;
+    return uses;
   };
 
   const getSubscriptions = subscriptions =>
@@ -56,12 +52,14 @@ module.exports = ({ actions, modifierActions }) => {
 
     subscriptions = getSubscriptions(subscriptions);
 
-    const isUnlimited = subscriptions.some(each => !each.numberOfUsesLimit);
+    const isUnlimited = subscriptions.some(
+      each => !each.usesLimit || each.renewalType === 'limit_reached'
+    );
     if (isUnlimited) return [true];
 
     const remaining = getRemaining(subscriptions, order.parentId || order._id);
-    const numberOfUses = getNumberOfUses(order.items, item);
+    const uses = getNumberOfUses(order.items, item);
 
-    return [remaining > numberOfUses, remaining, numberOfUses];
+    return [remaining > uses, remaining, uses];
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.112",
+  "version": "1.0.115",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -55,5 +55,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "ecde0ddb5fed6841e2ff1fa688120201557971cb"
+  "gitHead": "c2e7e75c33bf1253408a3fab94fe14d6f7fed2ec"
 }

package/lib/item/removeModifiersByQuantity.js

@@ -1,36 +0,0 @@
-module.exports = ({ modifierActions, utils }) =>
-  function removeModifiersByQuantity(item) {
-    if (!item || !Array.isArray(item.modifiers)) {
-      return item;
-    }
-
-    const modifierCounts = {};
-
-    return {
-      ...item,
-      modifiers: item.modifiers.filter(modifier => {
-        if (
-          modifierActions.isPaymentModifier(modifier) ||
-          modifierActions.isCalculatedPaymentModifier(modifier) ||
-          modifierActions.isGroupOfModifiers(modifier) ||
-          !modifier.modifierId ||
-          !modifierActions.isDirect(modifier) ||
-          modifierActions.isUnlimitedItemUse(modifier)
-        )
-          return true;
-
-        const count = modifierCounts[modifier.modifierId] || 0;
-
-        const maxApplies = modifierActions.getMaxItemUse(modifier) || 0;
-        const maxQuantity =
-          utils.math.mul(item.quantity || 0, maxApplies) || item.quantity;
-
-        if (count < maxQuantity) {
-          modifierCounts[modifier.modifierId] = count + 1;
-          return true;
-        }
-
-        return false;
-      }),
-    };
-  };