@darkpos/pricing 1.0.79 → 1.0.80

package/__TEST__/modifier.test.js

@@ -874,7 +874,7 @@ describe('Modifier actions', () => {
     });
   });
 
-  test('CU-86dve295v Should throw error when adding a modifier more times than the ones specified in properties.limits.maxAppliesItem', () => {
+  test('CU-86dve295v Should throw error when adding a modifier more times than the ones specified in properties.limits.maxItemUse', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -889,7 +889,7 @@ describe('Modifier actions', () => {
       },
       properties: {
         isQuantityMultiplier: true,
-        limits: { maxAppliesItem: 1 },
+        limits: { maxItemUse: 1 },
       },
     };
     order.items.push({
@@ -929,18 +929,26 @@ describe('Modifier actions', () => {
 
     expect(conditionsBag).toEqual([]);
     expect(error).toEqual('modifier.has.reached.the.maximum.amount.of.applies');
-    expect(updatedOrder2.items).toEqual([
+    expect(updatedOrder2.items[0].modifiers.length).toBe(1);
+    expect(updatedOrder2.items[0].modifiers).toMatchObject([
       {
-        itemId: '123',
-        modifiers: [],
-        price: 100,
-        properties: { basePrice: 100 },
-        quantity: 2,
+        compute: {
+          action: 'subtract',
+          amount: 10,
+          type: 'fixed',
+        },
+        modifierId: 1,
+        properties: {
+          isQuantityMultiplier: true,
+          limits: {
+            maxItemUse: 1,
+          },
+        },
       },
     ]);
   });
 
-  test('CU-86dve295v Should not throw error when adding a modifier less times than the ones specified in properties.limits.maxAppliesItem=5 and isQuantityMultiplier=false', () => {
+  test('CU-86dve295v Should not throw error when adding a modifier less times than the ones specified in properties.limits.maxItemUse=5 and isQuantityMultiplier=false', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -955,7 +963,7 @@ describe('Modifier actions', () => {
       },
       properties: {
         isQuantityMultiplier: false,
-        limits: { maxAppliesItem: 5 },
+        limits: { maxItemUse: 5 },
       },
     };
     order.items.push({
@@ -993,7 +1001,116 @@ describe('Modifier actions', () => {
     expect(currentOrder.items[0].modifiers.length).toBe(5);
   });
 
-  test('CU-86dve295v Should not throw error when adding a modifier if  properties.limits.isUnlimitedAppliesItem=true and isQuantityMultiplier=false', () => {
+  test('CU-86dve295v Should not throw error when adding a modifier less times than the ones specified in properties.limits.maxItemUse=5 and isQuantityMultiplier=false. Considering also the quantity', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: false,
+        limits: { maxItemUse: 5 },
+      },
+      direct: true,
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    let error = '';
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 10; i += 1) {
+      currentOrder = pricingService.order.addItemModifier({
+        order: currentOrder,
+        modifier,
+        itemIndex: 0,
+        onConditionsNotMet: bag => {
+          bag.forEach(condition => {
+            conditionsBag.push(condition);
+          });
+        },
+        // eslint-disable-next-line no-loop-func
+        onError: errorMessage => {
+          error = errorMessage;
+        },
+      });
+    }
+
+    expect(conditionsBag).toEqual([]);
+    expect(error).toEqual('');
+
+    const calculatedOrder = pricingService.order.calculate(currentOrder);
+
+    expect(calculatedOrder.items[0].modifiers.length).toBe(10);
+  });
+
+  test('CU-86dve295v Should throw error when adding a modifier 11 times to an item with quantity=2 and modifier.properties.limits.maxItemUse=5', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: false,
+        limits: { maxItemUse: 5 },
+      },
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    let error = '';
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 11; i += 1) {
+      currentOrder = pricingService.order.addItemModifier({
+        order: currentOrder,
+        modifier,
+        itemIndex: 0,
+        onConditionsNotMet: bag => {
+          bag.forEach(condition => {
+            conditionsBag.push(condition);
+          });
+        },
+        // eslint-disable-next-line no-loop-func
+        onError: errorMessage => {
+          error = errorMessage;
+        },
+      });
+    }
+
+    expect(conditionsBag).toEqual([]);
+    expect(error).toEqual('modifier.has.reached.the.maximum.amount.of.applies');
+
+    expect(currentOrder.items[0].modifiers.length).toBe(10);
+  });
+
+  test('CU-86dve295v Should not throw error when adding a modifier if  properties.limits.maxItemUse=-1 and isQuantityMultiplier=false', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -1008,7 +1125,7 @@ describe('Modifier actions', () => {
       },
       properties: {
         isQuantityMultiplier: false,
-        limits: { isUnlimitedAppliesItem: true },
+        limits: { maxItemUse: -1 },
       },
     };
     order.items.push({
@@ -1046,7 +1163,7 @@ describe('Modifier actions', () => {
     expect(currentOrder.items[0].modifiers.length).toBe(5);
   });
 
-  test('CU-86dve295v Should not add the modifiers more times than item.quantity if  modifier.properties.limits.isUnlimitedAppliesItem=false and modifier.properties.limits.maxAppliesItem is not set', () => {
+  test('CU-86dve295v Should not add the modifiers more times than item.quantity if modifier.properties.limits.maxItemUse is not set', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -1061,7 +1178,7 @@ describe('Modifier actions', () => {
       },
       properties: {
         isQuantityMultiplier: false,
-        limits: { isUnlimitedAppliesItem: false },
+        limits: { maxItemUse: 0 },
       },
     };
     order.items.push({
@@ -1098,4 +1215,123 @@ describe('Modifier actions', () => {
 
     expect(currentOrder.items[0].modifiers.length).toBe(2);
   });
+
+  test('CU-86dve295v Should add the modifier as many times as permitted by properties.limits.maxOrderUse', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: false,
+        limits: { maxOrderUse: 3 },
+      },
+    };
+    order.items.push({
+      quantity: 1,
+      itemId: '111',
+      price: 100,
+      modifiers: [],
+    });
+    order.items.push({
+      quantity: 1,
+      itemId: '222',
+      price: 100,
+      modifiers: [],
+    });
+    order.items.push({
+      quantity: 1,
+      itemId: '333',
+      price: 100,
+      modifiers: [],
+    });
+
+    order.items.push({
+      quantity: 1,
+      itemId: '444',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    let error = '';
+    let currentOrder = { ...order };
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+      onError: errorMessage => {
+        error = errorMessage;
+      },
+    });
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 1,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+      onError: errorMessage => {
+        error = errorMessage;
+      },
+    });
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 2,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+      onError: errorMessage => {
+        error = errorMessage;
+      },
+    });
+
+    expect(conditionsBag).toEqual([]);
+    expect(error).toEqual('');
+    expect(currentOrder.items[0].modifiers.length).toBe(1);
+    expect(currentOrder.items[1].modifiers.length).toBe(1);
+    expect(currentOrder.items[2].modifiers.length).toBe(1);
+    expect(currentOrder.items[3].modifiers.length).toBe(0);
+
+    expect(currentOrder.items.length).toBe(4);
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 3,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+      onError: errorMessage => {
+        error = errorMessage;
+      },
+    });
+
+    expect(conditionsBag).toEqual([]);
+    expect(error).toEqual('modifier.has.reached.the.maximum.amount.of.applies');
+    expect(currentOrder.items[3].modifiers.length).toBe(0);
+  });
 });

package/__TEST__/order/conditionsNotMet.test.js

@@ -680,4 +680,208 @@ describe('Conditions not met for the item', () => {
     expect(order.items[5].total).toBe(5);
     expect(order.items[5].modifiers.length).toBe(1);
   });
+
+  test('#8: Item number condition is met using aggregatedItems, rule is lastSelected', () => {
+    const mod3x2 = {
+      _id: '68069a18766f8687858461e7',
+      name: '3x2',
+      properties: {},
+      type: 'discount',
+      tags: ['default'],
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'itemSet',
+            value: { itemSet: '3', itemRule: 'lastSelected' },
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 100,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 3,
+    };
+
+    let order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item,
+    }).updatedOrder;
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+
+    expect(order.items.length).toEqual(1);
+
+    order = pricingService.order.calculate(order);
+
+    expect(order.total).toBe(20);
+    expect(order.items[0].total).toBe(20);
+    expect(order.items[0].modifiers.length).toBe(1);
+  });
+
+  test('#9: Item number condition is met using aggregatedItems and others, rule is lastSelected', () => {
+    const mod3x2 = {
+      _id: '68069a18766f8687858461e7',
+      name: '3x2',
+      properties: {},
+      type: 'discount',
+      tags: ['default'],
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'itemSet',
+            value: { itemSet: '3', itemRule: 'lastSelected' },
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 100,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 2,
+    };
+
+    const item2 = {
+      _id: 'bcd',
+      price: 10,
+      quantity: 1,
+    };
+
+    let order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item,
+    }).updatedOrder;
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+
+    order = pricingService.order.addItem({
+      order,
+      item: item2,
+    }).updatedOrder;
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+
+    expect(order.items.length).toEqual(2);
+
+    order = pricingService.order.calculate(order);
+
+    expect(order.total).toBe(20);
+    expect(order.items[0].total).toBe(0);
+    expect(order.items[0].modifiers.length).toBe(1);
+    expect(order.items[1].total).toBe(20);
+    expect(order.items[1].modifiers.length).toBe(1);
+  });
+
+  test('#10: Item number condition is met using aggregatedItems and others, rule is lastSelected', () => {
+    const mod3x2 = {
+      _id: '68069a18766f8687858461e7',
+      name: '3x2',
+      properties: {},
+      type: 'discount',
+      tags: ['default'],
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'itemSet',
+            value: { itemSet: '3', itemRule: 'lastSelected' },
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 100,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 3,
+    };
+
+    const item2 = {
+      _id: 'bcd',
+      price: 10,
+      quantity: 3,
+    };
+
+    let order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item,
+    }).updatedOrder;
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+
+    order = pricingService.order.addItem({
+      order,
+      item: item2,
+    }).updatedOrder;
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+
+    expect(order.items.length).toEqual(2);
+
+    order = pricingService.order.calculate(order);
+
+    expect(order.total).toBe(40);
+    expect(order.items[0].total).toBe(20);
+    expect(order.items[0].modifiers.length).toBe(1);
+    expect(order.items[1].total).toBe(20);
+    expect(order.items[1].modifiers.length).toBe(1);
+  });
 });

package/__TEST__/order/order.test.js

@@ -3700,7 +3700,7 @@ describe('Order actions', () => {
     expect(splittedOrders[1].items[0].quantity).toEqual(6);
   });
 
-  test('CU-86dve295v Should continue to add a modifier while its quantity is less than the specified in properties.limits.maxAppliesOrder=5', () => {
+  test('CU-86dve295v Should add a modifier just once at order level even if  properties.limits.maxOrderUse=5', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -3715,7 +3715,7 @@ describe('Order actions', () => {
       },
       modifierId: 'abc123',
       properties: {
-        limits: { maxAppliesOrder: 5 },
+        limits: { maxOrderUse: 5 },
       },
     };
     order.items.push({
@@ -3734,10 +3734,10 @@ describe('Order actions', () => {
       });
     }
 
-    expect(currentOrder.modifiers.length).toBe(5);
+    expect(currentOrder.modifiers.length).toBe(1);
   });
 
-  test('CU-86dve295v Should continue to add a modifier if properties.limits.isUnlimitedAppliesOrder=true', () => {
+  test('CU-86dve295v Should add the modifier just once at order level even if  properties.limits.maxOrderUse=-1', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -3752,7 +3752,7 @@ describe('Order actions', () => {
       },
       modifierId: 'abc123',
       properties: {
-        limits: { isUnlimitedAppliesOrder: true },
+        limits: { maxOrderUse: -1 },
       },
     };
     order.items.push({
@@ -3771,10 +3771,10 @@ describe('Order actions', () => {
       });
     }
 
-    expect(currentOrder.modifiers.length).toBe(5);
+    expect(currentOrder.modifiers.length).toBe(1);
   });
 
-  test('CU-86dve295v Should not add a modifier more than once if properties.limits.isUnlimitedAppliesOrder=false and properties.limits.maxAppliesOrder is not defined', () => {
+  test('CU-86dve295v Should not add a modifier more than once if properties.limits.maxOrderUse is not defined', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -3789,7 +3789,7 @@ describe('Order actions', () => {
       },
       modifierId: 'abc123',
       properties: {
-        limits: { isUnlimitedAppliesOrder: false, maxAppliesOrder: 0 },
+        limits: { maxOrderUse: 0 },
       },
     };
     order.items.push({
@@ -3810,4 +3810,57 @@ describe('Order actions', () => {
 
     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/item/getModifierTags.js

@@ -8,7 +8,7 @@ module.exports = ({ modifierActions, settings }) =>
     let modifierTags = item.modifiers
       .filter(
         each =>
-          (modifierActions.isValid(each) || modifierActions.isItemSet(each)) &&
+          modifierActions.isValid(each) &&
           (!modifierActions.isGroup(each) || modifierActions.isDepartment(each))
       )
 

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;
@@ -15,14 +15,15 @@ module.exports = ({ modifierActions }) =>
           modifierActions.isGroupOfModifiers(modifier) ||
           !modifier.modifierId ||
           !modifierActions.isDirect(modifier) ||
-          modifierActions.isUnlimitedAppliesItem(modifier)
+          modifierActions.isUnlimitedItemUse(modifier)
         )
           return true;
 
         const count = modifierCounts[modifier.modifierId] || 0;
 
-        const maxApplies = modifierActions.getMaxAppliesItem(modifier);
-        const maxQuantity = maxApplies || 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;

package/lib/modifier/areConditionsMet.js

@@ -32,29 +32,33 @@ module.exports = ({ actions, utils }) => {
                   }
                 });
 
-              const itemIndexInSorted = matchingItems.findIndex(
+              let totalItemsLength = 0;
+
+              matchingItems.forEach(matchItem => {
+                totalItemsLength += matchItem.quantity || 0;
+              });
+
+              const itemIndex = matchingItems.findIndex(
                 entry => entry._id === item._id
               );
 
-              const itemSet =
-                itemIndexInSorted >= 0 ? itemIndexInSorted + 1 : null;
-
-              const matchingItemsLength = matchingItems.length;
+              const itemSetIndex = itemIndex >= 0 ? itemIndex + 1 : null;
 
               if (
                 condition.operand === '$eq' &&
                 conditionValue &&
-                matchingItemsLength >= conditionValue
+                totalItemsLength >= conditionValue
               ) {
                 const result = Math.floor(
-                  utils.math.div(matchingItemsLength, conditionValue)
+                  utils.math.div(totalItemsLength, conditionValue)
                 );
-                if (itemSet <= result) {
+
+                if (itemSetIndex <= result) {
                   return true;
                 }
               }
               return actions.validateItemNumber(
-                itemSet,
+                itemSetIndex,
                 conditionValue,
                 condition.operand
               );
@@ -101,7 +105,6 @@ module.exports = ({ actions, utils }) => {
       startRequestDate = null,
       allItems = null,
     } = opts;
-    // const recommendedEndDate = storeActions.getRecommendedEndDate();
     return (
       modifier &&
       modifierConditionPass(modifier, {

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,13 +150,14 @@ 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 modifierActions = (deps = {}) => {
   const actions = {};
@@ -321,12 +322,13 @@ 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),
   });
 
   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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.79",
+  "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": "1ebec123fd5b4e7d3aaa6b259cd4467c9dccb74b"
+  "gitHead": "8c3967eacf0122f2024d9b29b66acc0e3a23d51d"
 }

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;
-  };