@darkpos/pricing 1.0.78 → 1.0.80

package/__TEST__/order/order.test.js

@@ -3699,4 +3699,168 @@ describe('Order actions', () => {
     expect(splittedOrders[1].items[0].name).toEqual(item1.name);
     expect(splittedOrders[1].items[0].quantity).toEqual(6);
   });
+
+  test('CU-86dve295v Should add a modifier just once at order level even if  properties.limits.maxOrderUse=5', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      modifierId: 'abc123',
+      properties: {
+        limits: { maxOrderUse: 5 },
+      },
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 5; i += 1) {
+      currentOrder = pricingService.order.addModifier({
+        order: currentOrder,
+        modifier,
+      });
+    }
+
+    expect(currentOrder.modifiers.length).toBe(1);
+  });
+
+  test('CU-86dve295v Should add the modifier just once at order level even if  properties.limits.maxOrderUse=-1', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      modifierId: 'abc123',
+      properties: {
+        limits: { maxOrderUse: -1 },
+      },
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 5; i += 1) {
+      currentOrder = pricingService.order.addModifier({
+        order: currentOrder,
+        modifier,
+      });
+    }
+
+    expect(currentOrder.modifiers.length).toBe(1);
+  });
+
+  test('CU-86dve295v Should not add a modifier more than once if properties.limits.maxOrderUse is not defined', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      modifierId: 'abc123',
+      properties: {
+        limits: { maxOrderUse: 0 },
+      },
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 5; i += 1) {
+      currentOrder = pricingService.order.addModifier({
+        order: currentOrder,
+        modifier,
+      });
+    }
+
+    expect(currentOrder.modifiers.length).toBe(1);
+  });
+
+  test('CU-86dve295v Should add to modifiers at order level', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      modifierId: 'abc123',
+      properties: {
+        limits: { maxOrderUse: 0 },
+      },
+    };
+
+    const modifier2 = {
+      _id: 2,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      modifierId: 'abc123',
+    };
+
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 5; i += 1) {
+      currentOrder = pricingService.order.addModifier({
+        order: currentOrder,
+        modifier,
+      });
+    }
+
+    currentOrder = pricingService.order.addModifier({
+      order: currentOrder,
+      modifier: modifier2,
+    });
+
+    expect(currentOrder.modifiers.length).toBe(2);
+  });
 });

package/lib/constants/Modifier/Attributes.js

@@ -6,4 +6,5 @@ module.exports = {
   LIST: 'list',
   DEPARTMENT: 'department',
   OVERRIDE: 'override',
+  LIMITS: 'limits',
 };

package/lib/item/calculate.js

@@ -11,6 +11,8 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
     const startRequestDate = opts.startRequestDate || null;
     const endRequestDate = opts.endRequestDate || null;
     const lockPaymentModifiers = !!opts.lockPaymentModifiers;
+    const allItems = Array.isArray(opts.items) ? opts.items : [];
+
     const { paymentId } = opts;
 
     if (!item) return item;
@@ -43,6 +45,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         item,
         startRequestDate,
         endRequestDate,
+        allItems,
       })
     );
 
@@ -195,10 +198,10 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
 
   //
   const calculateMany = (items = [], opts = null) =>
-    items.map(item => calculateOne(item, opts));
+    items.map(item => calculateOne(item, { ...opts, items }));
 
   return function calculate(item, opts) {
     if (Array.isArray(item)) return calculateMany(item, opts);
-    return calculateOne(item, opts);
+    return calculateOne(item, { ...opts });
   };
 };

package/lib/item/getModifierTags.js

@@ -11,6 +11,7 @@ module.exports = ({ modifierActions, settings }) =>
           modifierActions.isValid(each) &&
           (!modifierActions.isGroup(each) || modifierActions.isDepartment(each))
       )
+
       .map(modifier => {
         const { name, _id } = modifier;
 

package/lib/item/removeModifiersByQuantity.js

@@ -1,4 +1,4 @@
-module.exports = ({ modifierActions }) =>
+module.exports = ({ modifierActions, utils }) =>
   function removeModifiersByQuantity(item) {
     if (!item || !Array.isArray(item.modifiers)) {
       return item;
@@ -14,13 +14,18 @@ module.exports = ({ modifierActions }) =>
           modifierActions.isCalculatedPaymentModifier(modifier) ||
           modifierActions.isGroupOfModifiers(modifier) ||
           !modifier.modifierId ||
-          !modifierActions.isDirect(modifier)
+          !modifierActions.isDirect(modifier) ||
+          modifierActions.isUnlimitedItemUse(modifier)
         )
           return true;
 
         const count = modifierCounts[modifier.modifierId] || 0;
 
-        if (count < item.quantity) {
+        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;
         }

package/lib/modifier/areConditionsMet.js

@@ -1,11 +1,68 @@
-module.exports = ({ actions }) => {
+module.exports = ({ actions, utils }) => {
   const modifierConditionPass = (
     modifier,
-    { item, startRequestDate, endRequestDate }
+    { item, startRequestDate, endRequestDate, allItems }
   ) =>
     modifier.conditions && Array.isArray(modifier.conditions.rules)
       ? modifier.conditions.rules.every(condition => {
           switch (condition.key) {
+            case 'itemSet': {
+              if (!Array.isArray(allItems)) return true;
+              const conditionValue = Number(condition.value.itemSet || 0);
+              const conditionRule = condition.value.itemRule || 'lowestPrice';
+
+              const matchingItems = allItems
+                .filter(eachItem =>
+                  eachItem.modifiers.some(
+                    mod => mod.modifierId === modifier.modifierId
+                  )
+                )
+                .sort((a, b) => {
+                  switch (conditionRule) {
+                    case 'lowestPrice':
+                      return a.price - b.price;
+                    case 'highestPrice':
+                      return b.price - a.price;
+                    case 'firstSelected':
+                      return a._id.localeCompare(b._id);
+                    case 'lastSelected':
+                      return b._id.localeCompare(a._id);
+                    default:
+                      return 0;
+                  }
+                });
+
+              let totalItemsLength = 0;
+
+              matchingItems.forEach(matchItem => {
+                totalItemsLength += matchItem.quantity || 0;
+              });
+
+              const itemIndex = matchingItems.findIndex(
+                entry => entry._id === item._id
+              );
+
+              const itemSetIndex = itemIndex >= 0 ? itemIndex + 1 : null;
+
+              if (
+                condition.operand === '$eq' &&
+                conditionValue &&
+                totalItemsLength >= conditionValue
+              ) {
+                const result = Math.floor(
+                  utils.math.div(totalItemsLength, conditionValue)
+                );
+
+                if (itemSetIndex <= result) {
+                  return true;
+                }
+              }
+              return actions.validateItemNumber(
+                itemSetIndex,
+                conditionValue,
+                condition.operand
+              );
+            }
             case 'itemPieces':
               return actions.validateNumberCondition(
                 item.pieces,
@@ -46,14 +103,15 @@ module.exports = ({ actions }) => {
       item = null,
       endRequestDate = null,
       startRequestDate = null,
+      allItems = null,
     } = opts;
-    // const recommendedEndDate = storeActions.getRecommendedEndDate();
     return (
       modifier &&
       modifierConditionPass(modifier, {
         item,
         startRequestDate,
         endRequestDate,
+        allItems,
       })
     );
   }

package/lib/modifier/getMaxItemUse.js

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

package/lib/modifier/getMaxOrderUse.js

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

package/lib/modifier/index.js

@@ -150,6 +150,14 @@ const isGroupPath = require('./isGroupPath');
 const isSpreadFrom = require('./isSpreadFrom');
 const getRelatedModifiers = require('./getRelatedModifiers');
 const isRelatedModifier = require('./isRelatedModifier');
+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 modifierActions = (deps = {}) => {
   const actions = {};
@@ -281,6 +289,7 @@ const modifierActions = (deps = {}) => {
     getGroupedModifierLabels: getGroupedModifierLabels(innerDeps),
     validate: validate(innerDeps),
     validateNumberCondition: validateNumberCondition(innerDeps),
+    validateItemNumber: validateItemNumber(innerDeps),
     validateRequiredModifiers: validateRequiredModifiers(innerDeps),
     validateDateHoursDiff: validateDateHoursDiff(innerDeps),
     validateInArr: validateInArr(innerDeps),
@@ -313,6 +322,13 @@ const modifierActions = (deps = {}) => {
     isSpreadFrom: isSpreadFrom(innerDeps),
     getRelatedModifiers: getRelatedModifiers(innerDeps),
     isRelatedModifier: isRelatedModifier(innerDeps),
+    getMaxItemUse: getMaxItemUse(innerDeps),
+    getMaxOrderUse: getMaxOrderUse(innerDeps),
+    isUnlimitedItemUse: isUnlimitedItemUse(innerDeps),
+    isUnlimitedOrderUse: isUnlimitedOrderUse(innerDeps),
+    isLimits: isLimits(innerDeps),
+    isItemSet: isItemSet(innerDeps),
+    isOrderUseValid: isOrderUseValid(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isItemSet.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function isItemSet(modifier) {
+    if (
+      !modifier ||
+      !modifier.conditions ||
+      !Array.isArray(modifier.conditions.rules)
+    )
+      return false;
+
+    return modifier.conditions.rules.some(rule => rule.key === 'itemSet');
+  };

package/lib/modifier/isLimits.js

@@ -0,0 +1,9 @@
+module.exports = ({ actions, constants }) => {
+  const { Modifier } = constants;
+  return function isLimits(modifier) {
+    return (
+      actions.hasAttribute(modifier, Modifier.Attributes.LIMITS) ||
+      !!actions.getProperty(modifier, Modifier.Attributes.LIMITS)
+    );
+  };
+};

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/modifier/validateItemNumber.js

@@ -0,0 +1,18 @@
+module.exports = () =>
+  function validateItemNumber(itemSet, conditionNumber, operand) {
+    if (!conditionNumber && !operand) return true;
+    switch (operand) {
+      case '$ne':
+        return Number(conditionNumber) !== itemSet;
+      case '$gt':
+        return Number(conditionNumber) < itemSet;
+      case '$gte':
+        return Number(conditionNumber) <= itemSet;
+      case '$lt':
+        return Number(conditionNumber) > itemSet;
+      case '$lte':
+        return Number(conditionNumber) >= itemSet;
+      default:
+        return false;
+    }
+  };

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);
@@ -190,11 +204,24 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
       return order;
     }
     // Remove if it has it already only if it is not group of value or override modifier
+
+    const maxApplies = modifierActions.getMaxItemUse(modifier) || 0;
+    const isUnlimitedItemUse = modifierActions.isUnlimitedItemUse(modifier);
+
+    const maxQuantity =
+      math.mul(item.quantity || 0, maxApplies) || item.quantity;
+
     if (
+      !isUnlimitedItemUse &&
       contains &&
-      usingCount >= item.quantity &&
+      usingCount >= maxQuantity &&
       !modifierActions.isOverride(modifier)
     ) {
+      if (maxApplies && onError) {
+        onError('modifier.has.reached.the.maximum.amount.of.applies');
+        return order;
+      }
+
       order = actions.removeItemModifier({
         order,
         modifier,
@@ -239,11 +266,13 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     }
 
     item = addModifier({
+      order,
       item,
       modifier,
       originalItem,
       customer,
       onConditionsNotMet,
+      onError,
     });
 
     // Recursive Rules:
@@ -255,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,23 +1,15 @@
-module.exports = ({ actions, modifierActions }) => {
-  const { getComputeModField } = require('../modifier/utils');
-  return function addModifier({ order, modifier }) {
+module.exports = ({ modifierActions }) =>
+  function addModifier({ order, modifier }) {
     if (!modifier) return order;
-    const { modifiers = [] } = order;
-    if (modifierActions.isFixedDiscount(modifier)) {
-      const compute = getComputeModField(modifier);
-      const orderDue = actions.calculateDue(order);
-      if (compute.amount > orderDue) {
-        const err = new Error();
-        err.valid = false;
-        err.orderDue = orderDue;
-        err.message = 'discount.can.not.be.applied.order.due.is.this.amount';
-        throw err;
-      }
-    }
+
+    const orderModifiers = Array.isArray(order.modifiers)
+      ? order.modifiers
+      : [];
+
+    if (modifierActions.contains(orderModifiers, modifier)) return order;
 
     return {
       ...order,
-      modifiers: [...modifiers, { ...modifier }],
+      modifiers: [...orderModifiers, { ...modifier }],
     };
   };
-};

package/lib/order/getNumberOfItems.js

@@ -3,7 +3,7 @@ module.exports = ({ _ }) =>
     if (!orders || !Array.isArray(orders)) return 0;
     const sum = orders.reduce((acc, order) => {
       const items = _.get(order, 'items', []);
-      return acc + items.lenght;
+      return acc + items.length;
     }, 0);
 
     return sum;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.78",
+  "version": "1.0.80",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -51,5 +51,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "4e966b805abc74cc31cb0b3a0754e71f9bb913e5"
+  "gitHead": "8c3967eacf0122f2024d9b29b66acc0e3a23d51d"
 }