@darkpos/pricing 1.0.43 → 1.0.44

package/__TEST__/mocks/unpaid/order-modifiers.json

@@ -1,53 +1,49 @@
 [
-    {
-        "__typename": "Modifier",
-        "addModifiers": [],
-        "delModifiers": [],
-        "conditions": {
-            "__typename": "Conditions",
-            "paymentTypes": [
-                "cash"
-            ],
-            "paymentMethods": [],
-            "modifiers": [],
-            "minItemQuantity": 0,
-            "minItemPieces": 0
-        },
-        "compute": {
-            "__typename": "Compute",
-            "type": "fixed",
-            "action": "add",
-            "amount": 2
-        },
-        "_createdAt": "2022-11-08T16:09:49.227Z",
-        "_updatedAt": "2022-11-28T18:44:16.821Z",
-        "_id": "636a7f3ec19c040636f3da9a",
-        "modifierId": null,
-        "_parentId": null,
-        "locked": false,
-        "name": "Cash fee",
-        "sku": "",
-        "description": "",
-        "group": "",
-        "type": "fee",
-        "attributes": [],
-        "color": "",
-        "backgroundColor": "",
-        "icon": "",
-        "url": "",
-        "tags": [
-            "default"
-        ],
-        "order": 0,
-        "included": false,
-        "direct": true,
-        "hidden": false,
-        "print": true,
-        "required": false,
-        "recommended": false,
-        "default": false,
-        "code": "",
-        "properties": null,
-        "_computed": null
-    }
-]
+  {
+    "__typename": "Modifier",
+    "addModifiers": [],
+    "delModifiers": [],
+    "conditions": {
+      "rules": [ {
+        "key": "paymentTypes",
+        "operand": "$in",
+        "value": ["cash"]
+      }
+    ]
+    },
+    "compute": {
+      "__typename": "Compute",
+      "type": "fixed",
+      "action": "add",
+      "amount": 2
+    },
+    "_createdAt": "2022-11-08T16:09:49.227Z",
+    "_updatedAt": "2022-11-28T18:44:16.821Z",
+    "_id": "636a7f3ec19c040636f3da9a",
+    "modifierId": null,
+    "_parentId": null,
+    "locked": false,
+    "name": "Cash fee",
+    "sku": "",
+    "description": "",
+    "group": "",
+    "type": "fee",
+    "attributes": [],
+    "color": "",
+    "backgroundColor": "",
+    "icon": "",
+    "url": "",
+    "tags": ["default"],
+    "order": 0,
+    "included": false,
+    "direct": true,
+    "hidden": false,
+    "print": true,
+    "required": false,
+    "recommended": false,
+    "default": false,
+    "code": "",
+    "properties": null,
+    "_computed": null
+  }
+]

package/__TEST__/modifier/calculate.test.js

@@ -1,6 +1,7 @@
 const usePricing = require('../../index');
 
 const { getComputeModField } = require('../../lib/modifier/utils');
+
 const pricingService = usePricing();
 
 describe('Calculate Function', () => {

package/__TEST__/modifier/getMatchTagsModifiers.test.js

@@ -10,45 +10,75 @@ describe('GetMatchTagsModifiers Function', () => {
     const customer = {};
     let modifiers = [];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(0);
     customer.tags = [];
     modifiers = [{ tags: [] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     customer.tags = ['all'];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [{ tags: ['test'] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(0);
     modifiers = [{ tags: ['all'] }, { tags: ['test'] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [{ tags: ['all'] }, { tags: ['test'] }, { tags: [] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(2);
     customer.tags = ['test'];
     modifiers = [{ tags: [] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(0);
     modifiers = [{ tags: ['test'] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [{ tags: ['all'] }, { tags: ['test'] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [{ tags: ['all'] }, { tags: ['test'] }, { tags: [] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [
       { tags: ['all'] },
@@ -57,7 +87,10 @@ describe('GetMatchTagsModifiers Function', () => {
       { tags: ['Test'] },
     ];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [
       { tags: ['all'] },
@@ -67,15 +100,24 @@ describe('GetMatchTagsModifiers Function', () => {
       { tags: ['test', 'Test'] },
     ];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(2);
     modifiers = [{ tags: ['all'] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(0);
     modifiers = [{ tags: ['all'] }, { tags: ['test'] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [
       { tags: ['all'] },
@@ -84,11 +126,17 @@ describe('GetMatchTagsModifiers Function', () => {
       {},
     ];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(2);
     customer.tags = ['all'];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(2);
     modifiers = [
       { tags: ['all'] },
@@ -99,11 +147,17 @@ describe('GetMatchTagsModifiers Function', () => {
       {},
     ];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(5);
     customer.tags = undefined;
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(5);
   });
 });

package/__TEST__/modifier/getModifierIndex.test.js

@@ -12,7 +12,10 @@ describe('GetModifierIndex Function', () => {
     ).toBe(-1);
     const order = { modifiers: [{ modifierId: '123' }] };
     expect(
-      pricingService.modifier.getModifierIndex({ entity: order, modifier: undefined })
+      pricingService.modifier.getModifierIndex({
+        entity: order,
+        modifier: undefined,
+      })
     ).toBe(-1);
     const modifier = { _id: '123' };
     expect(
@@ -29,12 +32,12 @@ describe('GetModifierIndex Function', () => {
       })
     ).toBe(-1);
     order.modifiers = [{ modifierId: '123' }, { modifierId: '234' }];
-    expect(pricingService.modifier.getModifierIndex({ entity: order, modifier })).toBe(
-      1
-    );
+    expect(
+      pricingService.modifier.getModifierIndex({ entity: order, modifier })
+    ).toBe(1);
     modifier._id = '123';
-    expect(pricingService.modifier.getModifierIndex({ entity: order, modifier })).toBe(
-      0
-    );
+    expect(
+      pricingService.modifier.getModifierIndex({ entity: order, modifier })
+    ).toBe(0);
   });
 });

package/__TEST__/modifier/getRecommendedModifiers.test.js

@@ -5,13 +5,15 @@ const pricingService = usePricing();
 describe('GetRecommendedModifiers Function', () => {
   test('usecases', () => {
     const modifier = { modifier: { recommended: true } };
-    expect(pricingService.modifier.getRecommendedModifiers([modifier])).toHaveLength(1);
+    expect(
+      pricingService.modifier.getRecommendedModifiers([modifier])
+    ).toHaveLength(1);
 
     const modifier2 = {
       modifier: { modifier: { _id: 1 } },
     };
-    expect(pricingService.modifier.getRecommendedModifiers([modifier2])).toHaveLength(
-      0
-    );
+    expect(
+      pricingService.modifier.getRecommendedModifiers([modifier2])
+    ).toHaveLength(0);
   });
 });

package/__TEST__/modifier/hasAttribute.test.js

@@ -7,17 +7,23 @@ describe('Has Modifiers Function', () => {
     expect(pricingService.modifier.hasAttribute()).toBe(false);
     expect(pricingService.modifier.hasAttribute(undefined, 'test')).toBe(false);
     expect(pricingService.modifier.hasAttribute({}, undefined)).toBe(false);
-    expect(pricingService.modifier.hasAttribute({ attributes: [] }, undefined)).toBe(
-      false
-    );
     expect(
-      pricingService.modifier.hasAttribute({ attributes: [undefined] }, undefined)
+      pricingService.modifier.hasAttribute({ attributes: [] }, undefined)
+    ).toBe(false);
+    expect(
+      pricingService.modifier.hasAttribute(
+        { attributes: [undefined] },
+        undefined
+      )
     ).toBe(false);
     expect(
       pricingService.modifier.hasAttribute({ attributes: ['test'] }, undefined)
     ).toBe(false);
     expect(
-      pricingService.modifier.hasAttribute({ attributes: ['undefined'] }, undefined)
+      pricingService.modifier.hasAttribute(
+        { attributes: ['undefined'] },
+        undefined
+      )
     ).toBe(false);
     expect(
       pricingService.modifier.hasAttribute(

package/__TEST__/modifier/hasMatchTags.test.js

@@ -8,49 +8,71 @@ describe('Has Match Tags Function', () => {
     const customer = {};
     const modifier = {};
     expect(pricingService.modifier.hasMatchTags(customer)).toBe(true);
-    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(true);
+    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(
+      true
+    );
     customer.tags = [];
     modifier.tags = [];
     expect(pricingService.modifier.hasMatchTags(customer)).toBe(true);
-    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(true);
+    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(
+      true
+    );
     customer.tags = ['all'];
     modifier.tags = ['all'];
     expect(pricingService.modifier.hasMatchTags(customer)).toBe(true);
-    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(true);
+    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(
+      true
+    );
     customer.tags = ['All'];
     modifier.tags = ['All'];
     expect(pricingService.modifier.hasMatchTags(customer)).toBe(true);
-    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(true);
+    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(
+      true
+    );
     customer.tags = ['test'];
     modifier.tags = ['test'];
     expect(pricingService.modifier.hasMatchTags(customer)).toBe(false);
-    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(
+      false
+    );
     customer.tags = ['test'];
     modifier.tags = ['all'];
-    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(
+      false
+    );
     customer.tags = ['all'];
     modifier.tags = ['test'];
-    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(
+      false
+    );
     customer.tags = ['all'];
     modifier.tags = ['all'];
     expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(true);
     customer.tags = ['test'];
     modifier.tags = ['test2'];
-    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(
+      false
+    );
     customer.tags = ['test'];
     modifier.tags = ['test'];
     expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(true);
     customer.tags = ['test11', 'test12', 'test13', 'test14'];
     modifier.tags = ['test'];
-    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(
+      false
+    );
     customer.tags = ['test11', 'test12', 'test13', 'test14'];
     modifier.tags = ['test21', 'test22', 'test23', 'test24'];
-    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(
+      false
+    );
     customer.tags = ['test11', 'test12', 'test13', 'test14', 'match'];
     modifier.tags = ['test21', 'test22', 'test23', 'test24', 'match'];
     expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(true);
     customer.tags = ['test11', 'test12', 'test13', 'test14', 'Match'];
     modifier.tags = ['test21', 'test22', 'test23', 'test24', 'match'];
-    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(
+      false
+    );
   });
 });

package/__TEST__/modifier/sort.test.js

@@ -35,7 +35,7 @@ describe('Sort Function', () => {
       },
     ];
     const sortedModifiers = pricingService.modifier.sort(modifiers);
-    const ids = sortedModifiers.map((mob) => mob._id);
+    const ids = sortedModifiers.map(mob => mob._id);
     expect(ids).toMatchObject([1, 3, 2]);
   });
 });

package/__TEST__/order/conditionsNotMet.test.js

@@ -0,0 +1,133 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('Conditions not met for the item', () => {
+  test('#1: Item pieces condition is not met, errors bag populated', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const item = { pieces: 1, itemId: '123', price: 100, modifiers: [] };
+    order.items.push(item);
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'itemPieces',
+            value: 5,
+            operand: '$gt',
+          },
+        ],
+      },
+    };
+    const conditionsBag = [];
+    const { addItemModifier } = pricingService.order;
+    addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+    });
+    expect(conditionsBag).toEqual([
+      {
+        current: 1,
+        name: '$gt.itemPieces',
+        value: 5,
+      },
+    ]);
+  });
+  // Write two more tests for the other conditions
+  test('#2: Item quantity condition is not met, errors bag populated', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const item = { quantity: 1, itemId: '123', price: 100, modifiers: [] };
+    order.items.push(item);
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'itemQuantity',
+            value: 5,
+            operand: '$gt',
+          },
+        ],
+      },
+    };
+    const conditionsBag = [];
+    const { addItemModifier } = pricingService.order;
+    addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+    });
+    expect(conditionsBag).toEqual([
+      {
+        current: 1,
+        name: '$gt.itemQuantity',
+        value: 5,
+      },
+    ]);
+  });
+  test('#3: Required modifiers condition is not met, errors bag populated', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const item = {
+      quantity: 1,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    };
+    order.items.push(item);
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'modifiers',
+            value: [{ modifierId: 'mod-1' }],
+            operand: '$in',
+          },
+        ],
+      },
+    };
+    const conditionsBag = [];
+    const { addItemModifier } = pricingService.order;
+    addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+    });
+    expect(conditionsBag).toEqual([
+      {
+        current: [],
+        name: '$in.modifiers',
+        value: [
+          {
+            modifierId: 'mod-1',
+          },
+        ],
+      },
+    ]);
+  });
+});

package/__TEST__/order/order.test.js

@@ -119,7 +119,9 @@ describe('Order actions', () => {
 
     const order = { items: [item1, item2], modifiers: [modifier1] };
 
-    const newOrder = pricingService.order.calculate(order);
+    const newOrder = pricingService.order.calculate(order, {
+      paymentMethod: 'cash',
+    });
     expect(newOrder).toHaveProperty('total', 68);
     expect(newOrder).toHaveProperty('subTotal', 70);
     expect(newOrder).toHaveProperty('subTotals', {
@@ -1603,8 +1605,8 @@ describe('Order actions', () => {
       modifiers: paymentModifiers,
       order,
     });
-
-    const newOrder = pricingService.order.calculate(order);
+    const paymentMethod = { type: 'cash' };
+    const newOrder = pricingService.order.calculate(order, { paymentMethod });
 
     expect(newOrder).toHaveProperty('total', 34.45);
     expect(newOrder).toHaveProperty('subTotal', 42.45);
@@ -1631,8 +1633,8 @@ describe('Order actions', () => {
       modifiers: paymentModifiers,
       order,
     });
-
-    const newOrder = pricingService.order.calculate(order);
+    const paymentMethod = { type: 'cash' };
+    const newOrder = pricingService.order.calculate(order, { paymentMethod });
 
     expect(newOrder).toHaveProperty('total', 36.45);
     expect(newOrder).toHaveProperty('subTotal', 42.45);

package/__TEST__/order/pickEndDate.test.js

@@ -1,6 +1,6 @@
 const moment = require('moment-timezone');
 const _ = require('lodash');
-const pickEndDateFunction = require('../../lib/order/pickEndDate');
+const pickEndDateFunction = require('../../lib/store/pickEndDate');
 
 describe('pickEndDate function', () => {
   test('Get calculated Order, one item', () => {