@darkpos/pricing 1.0.77 → 1.0.79

package/__TEST__/modifier.test.js

@@ -873,4 +873,229 @@ describe('Modifier actions', () => {
       ]);
     });
   });
+
+  test('CU-86dve295v Should throw error when adding a modifier more times than the ones specified in properties.limits.maxAppliesItem', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: true,
+        limits: { maxAppliesItem: 1 },
+      },
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    const updatedOrder = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+    });
+
+    let error = '';
+    const updatedOrder2 = pricingService.order.addItemModifier({
+      order: { ...updatedOrder },
+      modifier,
+      itemIndex: 0,
+      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(updatedOrder2.items).toEqual([
+      {
+        itemId: '123',
+        modifiers: [],
+        price: 100,
+        properties: { basePrice: 100 },
+        quantity: 2,
+      },
+    ]);
+  });
+
+  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', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: false,
+        limits: { maxAppliesItem: 5 },
+      },
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    let error = '';
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 5; 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('');
+
+    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', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: false,
+        limits: { isUnlimitedAppliesItem: true },
+      },
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    let error = '';
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 5; 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('');
+
+    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', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: false,
+        limits: { isUnlimitedAppliesItem: false },
+      },
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    let error = '';
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 5; 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('');
+
+    expect(currentOrder.items[0].modifiers.length).toBe(2);
+  });
 });

package/__TEST__/order/conditionsNotMet.test.js

@@ -1,6 +1,10 @@
 const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
 
-const pricingService = usePricing();
+const session = {
+  store: mockStores[0],
+};
+const pricingService = usePricing(session);
 
 describe('Conditions not met for the item', () => {
   test('#1: Item pieces condition is not met, errors bag populated', () => {
@@ -42,7 +46,6 @@ describe('Conditions not met for the item', () => {
       },
     ]);
   });
-  // Write two more tests for the other conditions
   test('#2: Item quantity condition is not met, errors bag populated', () => {
     const order = {
       id: 'ord-123',
@@ -130,4 +133,551 @@ describe('Conditions not met for the item', () => {
       },
     ]);
   });
+
+  test('#4: Item number condition is met, errors bag empty', () => {
+    const mod3x2 = {
+      _id: '68069a18766f8687858461e7',
+      name: '3x2',
+      properties: {},
+      type: 'discount',
+      tags: ['default'],
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'itemSet',
+            value: { itemSet: '3' },
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 100,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+    };
+
+    let order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 2 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 50 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({ order, item }).updatedOrder;
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 1,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 2,
+    });
+
+    expect(order.items.length).toEqual(3);
+
+    order = pricingService.order.calculate(order);
+
+    expect(order.total).toBe(60);
+    expect(order.items[0].total).toBe(10);
+    expect(order.items[0].modifiers.length).toBe(1);
+
+    expect(order.items[1].total).toBe(50);
+    expect(order.items[1].modifiers.length).toBe(1);
+
+    expect(order.items[2].total).toBe(0);
+    expect(order.items[2].modifiers.length).toBe(1);
+  });
+
+  test('#5: Item number condition is met 2 times, errors bag empty', () => {
+    const mod3x2 = {
+      _id: '68069a18766f8687858461e7',
+      name: '3x2',
+      properties: {},
+      type: 'discount',
+      tags: ['default'],
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'itemSet',
+            value: { itemSet: '3' },
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 100,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+    };
+
+    let order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 5 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 4 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({ order, item }).updatedOrder;
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 10 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 10 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({ order, item }).updatedOrder;
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 1,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 2,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 3,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 4,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 5,
+    });
+
+    expect(order.items.length).toEqual(6);
+
+    order = pricingService.order.calculate(order);
+
+    expect(order.total).toBe(40);
+    expect(order.items[0].total).toBe(10);
+    expect(order.items[0].modifiers.length).toBe(1);
+
+    expect(order.items[1].total).toBe(10);
+    expect(order.items[1].modifiers.length).toBe(1);
+
+    expect(order.items[2].total).toBe(10);
+    expect(order.items[2].modifiers.length).toBe(1);
+
+    expect(order.items[3].total).toBe(10);
+    expect(order.items[3].modifiers.length).toBe(1);
+
+    expect(order.items[4].price).toBe(4);
+    expect(order.items[4].total).toBe(0);
+    expect(order.items[4].modifiers.length).toBe(1);
+
+    expect(order.items[5].price).toBe(5);
+    expect(order.items[5].total).toBe(0);
+    expect(order.items[5].modifiers.length).toBe(1);
+  });
+
+  test('#6: Item number condition is met, rule is highestPrice', () => {
+    const mod3x2 = {
+      _id: '68069a18766f8687858461e7',
+      name: '3x2',
+      properties: {},
+      type: 'discount',
+      tags: ['default'],
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'itemSet',
+            value: { itemSet: '3', itemRule: 'highestPrice' },
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 100,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+    };
+
+    let order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 5 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 4 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({ order, item }).updatedOrder;
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 10 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 10 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({ order, item }).updatedOrder;
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 1,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 2,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 3,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 4,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 5,
+    });
+
+    expect(order.items.length).toEqual(6);
+
+    order = pricingService.order.calculate(order);
+
+    expect(order.total).toBe(29);
+    expect(order.items[0].total).toBe(0);
+    expect(order.items[0].modifiers.length).toBe(1);
+
+    expect(order.items[1].total).toBe(0);
+    expect(order.items[1].modifiers.length).toBe(1);
+
+    expect(order.items[2].total).toBe(10);
+    expect(order.items[2].modifiers.length).toBe(1);
+
+    expect(order.items[3].total).toBe(10);
+    expect(order.items[3].modifiers.length).toBe(1);
+
+    expect(order.items[4].price).toBe(4);
+    expect(order.items[4].total).toBe(4);
+    expect(order.items[4].modifiers.length).toBe(1);
+
+    expect(order.items[5].price).toBe(5);
+    expect(order.items[5].total).toBe(5);
+    expect(order.items[5].modifiers.length).toBe(1);
+  });
+
+  test('#7: Item number condition is met, rule is firstSelected', () => {
+    const mod3x2 = {
+      _id: '68069a18766f8687858461e7',
+      name: '3x2',
+      properties: {},
+      type: 'discount',
+      tags: ['default'],
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'itemSet',
+            value: { itemSet: '3', itemRule: 'firstSelected' },
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 100,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+    };
+
+    let order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 5 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 4 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({ order, item }).updatedOrder;
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 10 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 10 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({ order, item }).updatedOrder;
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 1,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 2,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 3,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 4,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 5,
+    });
+
+    expect(order.items.length).toEqual(6);
+
+    order = pricingService.order.calculate(order);
+
+    expect(order.total).toBe(40);
+    expect(order.items[0].total).toBe(10);
+    expect(order.items[0].modifiers.length).toBe(1);
+
+    expect(order.items[1].total).toBe(10);
+    expect(order.items[1].modifiers.length).toBe(1);
+
+    expect(order.items[2].total).toBe(10);
+    expect(order.items[2].modifiers.length).toBe(1);
+
+    expect(order.items[3].total).toBe(10);
+    expect(order.items[3].modifiers.length).toBe(1);
+
+    expect(order.items[4].price).toBe(4);
+    expect(order.items[4].total).toBe(0);
+    expect(order.items[4].modifiers.length).toBe(1);
+
+    expect(order.items[5].price).toBe(5);
+    expect(order.items[5].total).toBe(0);
+    expect(order.items[5].modifiers.length).toBe(1);
+  });
+
+  test('#8: Item number condition is met, 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: 1,
+    };
+
+    let order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 5 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 4 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({ order, item }).updatedOrder;
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 10 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({
+      order,
+      item: { ...item, price: 10 },
+    }).updatedOrder;
+
+    order = pricingService.order.addItem({ order, item }).updatedOrder;
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 1,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 2,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 3,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 4,
+    });
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 5,
+    });
+
+    expect(order.items.length).toEqual(6);
+
+    order = pricingService.order.calculate(order);
+
+    expect(order.total).toBe(29);
+    expect(order.items[0].total).toBe(0);
+    expect(order.items[0].modifiers.length).toBe(1);
+
+    expect(order.items[1].total).toBe(0);
+    expect(order.items[1].modifiers.length).toBe(1);
+
+    expect(order.items[2].total).toBe(10);
+    expect(order.items[2].modifiers.length).toBe(1);
+
+    expect(order.items[3].total).toBe(10);
+    expect(order.items[3].modifiers.length).toBe(1);
+
+    expect(order.items[4].price).toBe(4);
+    expect(order.items[4].total).toBe(4);
+    expect(order.items[4].modifiers.length).toBe(1);
+
+    expect(order.items[5].price).toBe(5);
+    expect(order.items[5].total).toBe(5);
+    expect(order.items[5].modifiers.length).toBe(1);
+  });
 });

package/__TEST__/order/order.test.js

@@ -3699,4 +3699,115 @@ describe('Order actions', () => {
     expect(splittedOrders[1].items[0].name).toEqual(item1.name);
     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', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      modifierId: 'abc123',
+      properties: {
+        limits: { maxAppliesOrder: 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(5);
+  });
+
+  test('CU-86dve295v Should continue to add a modifier if properties.limits.isUnlimitedAppliesOrder=true', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      modifierId: 'abc123',
+      properties: {
+        limits: { isUnlimitedAppliesOrder: true },
+      },
+    };
+    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(5);
+  });
+
+  test('CU-86dve295v Should not add a modifier more than once if properties.limits.isUnlimitedAppliesOrder=false and properties.limits.maxAppliesOrder 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: { isUnlimitedAppliesOrder: false, maxAppliesOrder: 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);
+  });
 });

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

@@ -8,9 +8,10 @@ module.exports = ({ modifierActions, settings }) =>
     let modifierTags = item.modifiers
       .filter(
         each =>
-          modifierActions.isValid(each) &&
+          (modifierActions.isValid(each) || modifierActions.isItemSet(each)) &&
           (!modifierActions.isGroup(each) || modifierActions.isDepartment(each))
       )
+
       .map(modifier => {
         const { name, _id } = modifier;
 

package/lib/item/removeModifiersByQuantity.js

@@ -14,13 +14,17 @@ module.exports = ({ modifierActions }) =>
           modifierActions.isCalculatedPaymentModifier(modifier) ||
           modifierActions.isGroupOfModifiers(modifier) ||
           !modifier.modifierId ||
-          !modifierActions.isDirect(modifier)
+          !modifierActions.isDirect(modifier) ||
+          modifierActions.isUnlimitedAppliesItem(modifier)
         )
           return true;
 
         const count = modifierCounts[modifier.modifierId] || 0;
 
-        if (count < item.quantity) {
+        const maxApplies = modifierActions.getMaxAppliesItem(modifier);
+        const maxQuantity = maxApplies || item.quantity;
+
+        if (count < maxQuantity) {
           modifierCounts[modifier.modifierId] = count + 1;
           return true;
         }

package/lib/modifier/areConditionsMet.js

@@ -1,11 +1,64 @@
-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;
+                  }
+                });
+
+              const itemIndexInSorted = matchingItems.findIndex(
+                entry => entry._id === item._id
+              );
+
+              const itemSet =
+                itemIndexInSorted >= 0 ? itemIndexInSorted + 1 : null;
+
+              const matchingItemsLength = matchingItems.length;
+
+              if (
+                condition.operand === '$eq' &&
+                conditionValue &&
+                matchingItemsLength >= conditionValue
+              ) {
+                const result = Math.floor(
+                  utils.math.div(matchingItemsLength, conditionValue)
+                );
+                if (itemSet <= result) {
+                  return true;
+                }
+              }
+              return actions.validateItemNumber(
+                itemSet,
+                conditionValue,
+                condition.operand
+              );
+            }
             case 'itemPieces':
               return actions.validateNumberCondition(
                 item.pieces,
@@ -46,6 +99,7 @@ module.exports = ({ actions }) => {
       item = null,
       endRequestDate = null,
       startRequestDate = null,
+      allItems = null,
     } = opts;
     // const recommendedEndDate = storeActions.getRecommendedEndDate();
     return (
@@ -54,6 +108,7 @@ module.exports = ({ actions }) => {
         item,
         startRequestDate,
         endRequestDate,
+        allItems,
       })
     );
   }

package/lib/modifier/getMaxAppliesItem.js

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

package/lib/modifier/getMaxAppliesOrder.js

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

package/lib/modifier/index.js

@@ -150,6 +150,13 @@ 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 validateItemNumber = require('./validateItemNumber');
+const isLimits = require('./isLimits');
+const isItemSet = require('./isItemSet');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -281,6 +288,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 +321,12 @@ const modifierActions = (deps = {}) => {
     isSpreadFrom: isSpreadFrom(innerDeps),
     getRelatedModifiers: getRelatedModifiers(innerDeps),
     isRelatedModifier: isRelatedModifier(innerDeps),
+    getMaxAppliesItem: getMaxAppliesItem(innerDeps),
+    getMaxAppliesOrder: getMaxAppliesOrder(innerDeps),
+    isUnlimitedAppliesItem: isUnlimitedAppliesItem(innerDeps),
+    isUnlimitedAppliesOrder: isUnlimitedAppliesOrder(innerDeps),
+    isLimits: isLimits(innerDeps),
+    isItemSet: isItemSet(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/isUnlimitedAppliesItem.js

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

package/lib/modifier/isUnlimitedAppliesOrder.js

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

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

@@ -190,11 +190,19 @@ 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.getMaxAppliesItem(modifier);
+    const maxQuantity = maxApplies || item.quantity;
+
     if (
+      !modifierActions.isUnlimitedAppliesItem(modifier) &&
       contains &&
-      usingCount >= item.quantity &&
+      usingCount >= maxQuantity &&
       !modifierActions.isOverride(modifier)
     ) {
+      if (maxApplies && onError)
+        onError('modifier.has.reached.the.maximum.amount.of.applies');
+
       order = actions.removeItemModifier({
         order,
         modifier,

package/lib/order/addModifier.js

@@ -1,23 +1,25 @@
-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;
+
+    let usingCount = 0;
+
+    modifiers.forEach(orderMod => {
+      if (orderMod.modifierId === modifier.modifierId) {
+        usingCount += 1;
       }
-    }
+    });
+    const maxQty = modifierActions.getMaxAppliesOrder(modifier) || 1;
+
+    if (
+      modifierActions.isUnlimitedAppliesOrder(modifier) ||
+      usingCount < maxQty
+    )
+      return {
+        ...order,
+        modifiers: [...modifiers, { ...modifier }],
+      };
 
-    return {
-      ...order,
-      modifiers: [...modifiers, { ...modifier }],
-    };
+    return order;
   };
-};

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.77",
+  "version": "1.0.79",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@darkpos/utils": "^1.0.11",
+    "@darkpos/utils": "^1.0.12",
     "crypto-js": "^4.2.0",
     "lodash": "^4.17.21",
     "moment-timezone": "^0.5.34"
@@ -51,5 +51,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "5ef669119ac8baec449e3c0aee06151d0cd4ad63"
+  "gitHead": "1ebec123fd5b4e7d3aaa6b259cd4467c9dccb74b"
 }

package/lib/constants/status.js

@@ -1,39 +0,0 @@
-const Order = Object.freeze({
-  OPEN: 'open',
-  HOLD: 'hold',
-  VOID: 'void',
-  CLOSED: 'close',
-});
-
-const Invoice = Object.freeze({
-  PARTIAL: 'partial',
-  PENDING: 'pending',
-  CLOSED: 'close',
-});
-
-const Kitchen = Object.freeze({
-  OPEN: 'open',
-  CLOSED: 'closed',
-});
-
-const Delivery = Object.freeze({
-  NONE: 'none',
-  BOOKED: 'booked',
-  PICKED: 'picked',
-  DELIVER: 'deliver',
-  DELIVERED: 'delivered',
-  DELIVERED_PARTIAL: 'delivered.partial',
-  RETURNED: 'returned',
-  RETURNED_PARTIAL: 'returned.partial',
-  HELD_NOT_READY: 'held.not.ready',
-  HELD_FOR_RELEASE_APPROVAL: 'held.for.release.approval',
-  CANCELLED: 'cancelled',
-  LOST: 'lost',
-});
-
-module.exports = Object.freeze({
-  Order,
-  Invoice,
-  Kitchen,
-  Delivery,
-});