@darkpos/pricing 1.0.79 → 1.0.81

package/lib/modifier/getSplittedModifiers.js

@@ -3,28 +3,21 @@ module.exports = ({ utils }) => {
   const { getComputeModField } = require('./utils');
 
   const divideModifierAmount = ({
-    totalOriginOrder,
+    totalOrigin,
     modifierAmount,
-    totalSplitedOrder,
+    totalSplited,
   }) =>
-    totalOriginOrder
+    totalOrigin
       ? math.toDecimalPlaces(
-          math.div(
-            math.mul(modifierAmount, totalSplitedOrder || 0),
-            totalOriginOrder
-          )
+          math.div(math.mul(modifierAmount, totalSplited || 0), totalOrigin)
         )
       : 0;
 
-  const splitCreditModifier = ({
-    modifier,
-    totalOriginOrder,
-    totalSplitedOrder,
-  }) => {
+  const splitCreditModifier = ({ modifier, totalOrigin, totalSplited }) => {
     const maxAmount = divideModifierAmount({
       modifierAmount: modifier.properties.maxAmount,
-      totalOriginOrder,
-      totalSplitedOrder,
+      totalOrigin,
+      totalSplited,
     });
     const compute = getComputeModField(modifier);
     return {
@@ -39,15 +32,11 @@ module.exports = ({ utils }) => {
     };
   };
 
-  const splitFixedModifier = ({
-    modifier,
-    totalOriginOrder,
-    totalSplitedOrder,
-  }) => {
+  const splitFixedModifier = ({ modifier, totalOrigin, totalSplited }) => {
     const amount = divideModifierAmount({
       modifierAmount: modifier.compute.amount,
-      totalOriginOrder,
-      totalSplitedOrder,
+      totalOrigin,
+      totalSplited,
     });
     return {
       ...modifier,
@@ -58,27 +47,23 @@ module.exports = ({ utils }) => {
     };
   };
 
-  return function getSplittedModifiers(
-    modifiers,
-    totalOriginOrder,
-    totalSplitedOrder
-  ) {
+  return function getSplittedModifiers(modifiers, totalOrigin, totalSplited) {
     return modifiers.map(each => {
       const modifier = { ...each };
       const compute = getComputeModField(modifier);
       if (modifier.type === 'credit') {
         return splitCreditModifier({
           modifier,
-          totalOriginOrder,
-          totalSplitedOrder,
+          totalOrigin,
+          totalSplited,
         });
       }
 
       if (compute && compute.type === 'fixed' && compute.amount) {
         return splitFixedModifier({
           modifier,
-          totalOriginOrder,
-          totalSplitedOrder,
+          totalOrigin,
+          totalSplited,
         });
       }
       return modifier;

package/lib/modifier/index.js

@@ -54,6 +54,8 @@ const getSuggestion = require('./getSuggestion');
 const getUnhiddenModifiers = require('./getUnhiddenModifiers');
 const getUsingCount = require('./getUsingCount');
 const getFixedModifiersTotal = require('./getFixedModifiersTotal');
+const getFixedModifiersTotalEntities = require('./getFixedModifiersTotalEntities');
+const getCreditModifiersTotalEntities = require('./getCreditModifiersTotalEntities');
 const getCreditModifiersTotal = require('./getCreditModifiersTotal');
 const hasAddModifiers = require('./hasAddModifiers');
 const hasAllTag = require('./hasAllTag');
@@ -150,13 +152,15 @@ const isGroupPath = require('./isGroupPath');
 const isSpreadFrom = require('./isSpreadFrom');
 const getRelatedModifiers = require('./getRelatedModifiers');
 const isRelatedModifier = require('./isRelatedModifier');
-const getMaxAppliesItem = require('./getMaxAppliesItem');
-const getMaxAppliesOrder = require('./getMaxAppliesOrder');
-const isUnlimitedAppliesItem = require('./isUnlimitedAppliesItem');
-const isUnlimitedAppliesOrder = require('./isUnlimitedAppliesOrder');
+const getMaxItemUse = require('./getMaxItemUse');
+const getMaxOrderUse = require('./getMaxOrderUse');
+const isUnlimitedItemUse = require('./isUnlimitedItemUse');
+const isUnlimitedOrderUse = require('./isUnlimitedOrderUse');
 const validateItemNumber = require('./validateItemNumber');
 const isLimits = require('./isLimits');
 const isItemSet = require('./isItemSet');
+const isOrderUseValid = require('./isOrderUseValid');
+const getMaxItemQuantity = require('./getMaxItemQuantity');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -321,12 +325,16 @@ const modifierActions = (deps = {}) => {
     isSpreadFrom: isSpreadFrom(innerDeps),
     getRelatedModifiers: getRelatedModifiers(innerDeps),
     isRelatedModifier: isRelatedModifier(innerDeps),
-    getMaxAppliesItem: getMaxAppliesItem(innerDeps),
-    getMaxAppliesOrder: getMaxAppliesOrder(innerDeps),
-    isUnlimitedAppliesItem: isUnlimitedAppliesItem(innerDeps),
-    isUnlimitedAppliesOrder: isUnlimitedAppliesOrder(innerDeps),
+    getMaxItemUse: getMaxItemUse(innerDeps),
+    getMaxOrderUse: getMaxOrderUse(innerDeps),
+    isUnlimitedItemUse: isUnlimitedItemUse(innerDeps),
+    isUnlimitedOrderUse: isUnlimitedOrderUse(innerDeps),
     isLimits: isLimits(innerDeps),
     isItemSet: isItemSet(innerDeps),
+    isOrderUseValid: isOrderUseValid(innerDeps),
+    getMaxItemQuantity: getMaxItemQuantity(innerDeps),
+    getFixedModifiersTotalEntities: getFixedModifiersTotalEntities(innerDeps),
+    getCreditModifiersTotalEntities: getCreditModifiersTotalEntities(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isOrderUseValid.js

@@ -0,0 +1,25 @@
+module.exports = ({ actions }) =>
+  function isOrderUseValid({ order, modifier, item: itemParam }) {
+    if (
+      !actions.isLimits(modifier) ||
+      actions.isUnlimitedOrderUse(modifier) ||
+      !actions.getMaxOrderUse(modifier)
+    )
+      return true;
+
+    const limit = actions.getMaxOrderUse(modifier);
+
+    const usedIn = new Set();
+
+    // eslint-disable-next-line no-restricted-syntax
+    for (const item of order.items) {
+      if (item.modifiers.some(mod => mod.modifierId === modifier._id)) {
+        usedIn.add(item.itemId);
+      }
+    }
+
+    if (itemParam && itemParam.itemId && usedIn.has(itemParam.itemId))
+      return true;
+
+    return usedIn.size < limit;
+  };

package/lib/modifier/isUnlimitedItemUse.js

@@ -0,0 +1,4 @@
+module.exports = ({ actions }) =>
+  function isUnlimitedItemUse(modifier) {
+    return actions.getMaxItemUse(modifier) === -1;
+  };

package/lib/modifier/isUnlimitedOrderUse.js

@@ -0,0 +1,4 @@
+module.exports = ({ actions }) =>
+  function isUnlimitedOrderUse(modifier) {
+    return actions.getMaxOrderUse(modifier) === -1;
+  };

package/lib/order/addItemModifier.js

@@ -86,12 +86,26 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
   };
 
   const addModifier = ({
+    order,
     modifier: _modifier,
     item: itemProp,
     customer,
     originalItem,
     onConditionsNotMet,
+    onError,
   }) => {
+    if (
+      !modifierActions.isOrderUseValid({
+        order,
+        modifier: _modifier,
+        item: itemProp,
+      })
+    ) {
+      onError('modifier.has.reached.the.maximum.amount.of.applies');
+
+      return itemProp;
+    }
+
     const modifier = modifierActions.removeGroupRelations(_modifier); // to avoid no param reassign lint rule
     let item = { ...itemProp };
     const compute = getComputeModField(modifier);
@@ -191,17 +205,22 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     }
     // Remove if it has it already only if it is not group of value or override modifier
 
-    const maxApplies = modifierActions.getMaxAppliesItem(modifier);
-    const maxQuantity = maxApplies || item.quantity;
+    const maxApplies = modifierActions.getMaxItemUse(modifier) || 0;
+    const isUnlimitedItemUse = modifierActions.isUnlimitedItemUse(modifier);
+
+    const maxQuantity =
+      math.mul(item.quantity || 0, maxApplies) || item.quantity;
 
     if (
-      !modifierActions.isUnlimitedAppliesItem(modifier) &&
+      !isUnlimitedItemUse &&
       contains &&
       usingCount >= maxQuantity &&
       !modifierActions.isOverride(modifier)
     ) {
-      if (maxApplies && onError)
+      if (maxApplies && onError) {
         onError('modifier.has.reached.the.maximum.amount.of.applies');
+        return order;
+      }
 
       order = actions.removeItemModifier({
         order,
@@ -247,11 +266,13 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     }
 
     item = addModifier({
+      order,
       item,
       modifier,
       originalItem,
       customer,
       onConditionsNotMet,
+      onError,
     });
 
     // Recursive Rules:
@@ -263,10 +284,12 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
       item = relatedModifiers.reduce(
         (acc, each) =>
           addModifier({
+            order,
             item: acc,
             modifier: each,
             originalItem,
             customer,
+            onError,
           }),
         item
       );

package/lib/order/addModifier.js

@@ -1,25 +1,15 @@
 module.exports = ({ modifierActions }) =>
   function addModifier({ order, modifier }) {
     if (!modifier) return order;
-    const { modifiers = [] } = order;
 
-    let usingCount = 0;
+    const orderModifiers = Array.isArray(order.modifiers)
+      ? order.modifiers
+      : [];
 
-    modifiers.forEach(orderMod => {
-      if (orderMod.modifierId === modifier.modifierId) {
-        usingCount += 1;
-      }
-    });
-    const maxQty = modifierActions.getMaxAppliesOrder(modifier) || 1;
+    if (modifierActions.contains(orderModifiers, modifier)) return order;
 
-    if (
-      modifierActions.isUnlimitedAppliesOrder(modifier) ||
-      usingCount < maxQty
-    )
-      return {
-        ...order,
-        modifiers: [...modifiers, { ...modifier }],
-      };
-
-    return order;
+    return {
+      ...order,
+      modifiers: [...orderModifiers, { ...modifier }],
+    };
   };

package/lib/order/index.js

@@ -73,8 +73,6 @@ const getAppliedCredit = require('./getAppliedCredit');
 const addCreditModifier = require('./addCreditModifier');
 const adjustCreditModifiersDifference = require('./adjustCreditModifiersDifference');
 const adjustFixedModifiersDifference = require('./adjustFixedModifiersDifference');
-const getCreditModifiersTotal = require('./getCreditModifiersTotal');
-const getFixedModifiersTotal = require('./getFixedModifiersTotal');
 const splitAndCalculate = require('./splitAndCalculate');
 const spreadModifiers = require('./spreadModifiers');
 const validateCreditModifiersTotal = require('./validateCreditModifiersTotal');
@@ -90,6 +88,7 @@ const getBalance = require('./getBalance');
 const getLastLocation = require('./getLastLocation');
 const getModifierRelations = require('./getModifierRelations');
 const resetItem = require('./resetItem');
+const splitItems = require('./splitItems');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -174,8 +173,6 @@ const orderActions = (deps = {}) => {
     addCreditModifier: addCreditModifier(innerDeps),
     adjustCreditModifiersDifference: adjustCreditModifiersDifference(innerDeps),
     adjustFixedModifiersDifference: adjustFixedModifiersDifference(innerDeps),
-    getCreditModifiersTotal: getCreditModifiersTotal(innerDeps),
-    getFixedModifiersTotal: getFixedModifiersTotal(innerDeps),
     splitAndCalculate: splitAndCalculate(innerDeps),
     spreadModifiers: spreadModifiers(innerDeps),
     validateCreditModifiersTotal: validateCreditModifiersTotal(innerDeps),
@@ -191,6 +188,7 @@ const orderActions = (deps = {}) => {
     getLastLocation: getLastLocation(innerDeps),
     getModifierRelations: getModifierRelations(innerDeps),
     resetItem: resetItem(innerDeps),
+    splitItems: splitItems(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/splitItems.js

@@ -0,0 +1,50 @@
+module.exports = ({ actions, modifierActions, itemActions }) =>
+  function splitItems({ order }) {
+    if (!order || !order.items) return order;
+
+    const newItems = [];
+    let shouldRecalculate = false;
+
+    order.items.forEach(item => {
+      if (!item.modifiers) {
+        newItems.push(item);
+        return;
+      }
+
+      const maxItemQuantityMod = item.modifiers.find(mod =>
+        modifierActions.getMaxItemQuantity(mod)
+      );
+
+      const maxQuantity =
+        modifierActions.getMaxItemQuantity(maxItemQuantityMod);
+
+      if (!maxQuantity || item.quantity <= maxQuantity) {
+        newItems.push(item);
+        return;
+      }
+
+      let remaining = item.quantity;
+      let spreadedItems = [];
+      while (remaining > 0) {
+        if (!shouldRecalculate) shouldRecalculate = true;
+        const splitQty = Math.min(remaining, maxQuantity);
+        spreadedItems.push({
+          ...item,
+          quantity: splitQty,
+          modifiers: [],
+        });
+        remaining -= splitQty;
+      }
+
+      spreadedItems = itemActions.spreadModifiers({
+        parentItem: item,
+        subItems: spreadedItems,
+      });
+
+      newItems.push(...spreadedItems);
+    });
+
+    return shouldRecalculate
+      ? actions.calculate({ ...order, items: newItems })
+      : order;
+  };

package/lib/order/validateCreditModifiersTotal.js

@@ -6,7 +6,7 @@ module.exports = ({ utils, actions, modifierActions }) => {
       parentOrder.modifiers
     );
     const subOrdersCreditModifiersTotalAmount =
-      actions.getCreditModifiersTotal(subOrders);
+      modifierActions.getCreditModifiersTotalEntities(subOrders);
 
     if (creditModifiersTotalAmount !== subOrdersCreditModifiersTotalAmount) {
       return actions.adjustCreditModifiersDifference({

package/lib/order/validateFixedModifiersTotal.js

@@ -6,7 +6,7 @@ module.exports = ({ utils, actions, modifierActions }) => {
       parentOrder.modifiers
     );
     const subOrdersFixedModifiersTotalAmount =
-      actions.getFixedModifiersTotal(subOrders);
+      modifierActions.getFixedModifiersTotalEntities(subOrders);
 
     if (fixedModifiersTotalAmount !== subOrdersFixedModifiersTotalAmount) {
       return actions.adjustFixedModifiersDifference({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.79",
+  "version": "1.0.81",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -51,5 +51,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "1ebec123fd5b4e7d3aaa6b259cd4467c9dccb74b"
+  "gitHead": "41babe2d2f61ea0fac42d1f76c1c98a3afde8507"
 }

package/lib/modifier/getMaxAppliesItem.js

@@ -1,5 +0,0 @@
-module.exports = ({ actions }) =>
-  function getMaxAppliesItem(modifier) {
-    if (!actions.isLimits(modifier)) return false;
-    return modifier.properties.limits.maxAppliesItem;
-  };

package/lib/modifier/getMaxAppliesOrder.js

@@ -1,5 +0,0 @@
-module.exports = ({ actions }) =>
-  function getMaxAppliesOrder(modifier) {
-    if (!actions.isLimits(modifier)) return false;
-    return modifier.properties.limits.maxAppliesOrder;
-  };

package/lib/modifier/isUnlimitedAppliesItem.js

@@ -1,6 +0,0 @@
-module.exports = ({ actions }) =>
-  function isUnlimitedAppliesItem(modifier) {
-    if (!actions.isLimits(modifier)) return false;
-
-    return !!modifier.properties.limits.isUnlimitedAppliesItem;
-  };

package/lib/modifier/isUnlimitedAppliesOrder.js

@@ -1,6 +0,0 @@
-module.exports = ({ actions }) =>
-  function isUnlimitedAppliesOrder(modifier) {
-    if (!actions.isLimits(modifier)) return false;
-
-    return !!modifier.properties.limits.isUnlimitedAppliesOrder;
-  };

package/lib/order/getCreditModifiersTotal.js

@@ -1,15 +0,0 @@
-module.exports = ({ utils, modifierActions }) => {
-  const { math } = utils;
-
-  return function getCreditModifiersTotal(orders) {
-    if (!Array.isArray(orders)) return 0;
-    return orders.reduce(
-      (acc, subOrder) =>
-        math.add(
-          acc,
-          modifierActions.getCreditModifiersTotal(subOrder.modifiers)
-        ),
-      0
-    );
-  };
-};

package/lib/order/getFixedModifiersTotal.js

@@ -1,15 +0,0 @@
-module.exports = ({ utils, modifierActions }) => {
-  const { math } = utils;
-
-  return function getFixedModifiersTotal(orders) {
-    if (!Array.isArray(orders)) return 0;
-    return orders.reduce(
-      (acc, subOrder) =>
-        math.add(
-          acc,
-          modifierActions.getFixedModifiersTotal(subOrder.modifiers)
-        ),
-      0
-    );
-  };
-};