@darkpos/pricing 1.0.110 → 1.0.111

package/__TEST__/modifier/isModifierValid.test.js

@@ -0,0 +1,58 @@
+const moment = require('moment-timezone');
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('Is valid Modifier', () => {
+  test('should return false if promo riched the limits', () => {
+    const today = moment();
+
+    const mockPromoModifier = {
+      attributes: ['promotion'],
+      name: 'Waly Promo',
+      sku: '#WALYPROMO',
+      properties: {
+        override: null,
+        sort: null,
+        promotion: {
+          numberOfUsesLimit: 4,
+          dateLimit: {
+            from: today.subtract(1, 'week').format('YYYY-MM-DD'),
+            to: moment().subtract(1, 'day').format('YYYY-MM-DD'),
+          },
+          numberOfUses: 3,
+        },
+      },
+    };
+    const isPromoValid =
+      pricingService.modifier.isModifierValid(mockPromoModifier);
+
+    expect(isPromoValid).toBe(false);
+  });
+
+  test('should return true if promo has not riched the limits', () => {
+    const today = moment();
+
+    const mockPromoModifier = {
+      attributes: ['promotion'],
+      name: 'Waly Promo',
+      sku: '#WALYPROMO',
+      properties: {
+        override: null,
+        sort: null,
+        promotion: {
+          numberOfUsesLimit: 4,
+          dateLimit: {
+            from: today.subtract(1, 'day').format('YYYY-MM-DD'),
+            to: moment().add(1, 'day').format('YYYY-MM-DD'),
+          },
+          numberOfUses: 2,
+        },
+      },
+    };
+    const isPromoValid =
+      pricingService.modifier.isModifierValid(mockPromoModifier);
+
+    expect(isPromoValid).toBe(true);
+  });
+});

package/__TEST__/order/conditionsNotMet.test.js

@@ -1624,4 +1624,156 @@ describe('Conditions not met for the item', () => {
       undefined
     );
   });
+
+  test('Total number of items conditions is  met, using between', () => {
+    const item1 = { pieces: 1, itemId: '1', price: 100, modifiers: [] };
+    const item2 = { pieces: 1, itemId: '2', price: 100, modifiers: [] };
+    const item3 = { pieces: 1, itemId: '3', price: 100, modifiers: [] };
+    const item4 = { pieces: 1, itemId: '4', price: 100, modifiers: [] };
+    const item5 = { pieces: 1, itemId: '5', price: 100, modifiers: [] };
+    const item6 = { pieces: 1, itemId: '6', price: 100, modifiers: [] };
+
+    const order = {
+      id: 'ord-123',
+      items: [item1, item2, item3, item4, item5, item6],
+      modifiers: [],
+    };
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'totalNumberOfItems',
+            value: {
+              from: 5,
+              to: 15,
+            },
+            operand: '$between',
+          },
+        ],
+      },
+    };
+    const { addItemModifier } = pricingService.order;
+    const calculatedOrder = pricingService.order.calculate(
+      addItemModifier({
+        order,
+        modifier,
+        itemIndex: 0,
+      })
+    );
+    expect(calculatedOrder.items[0].modifiers.length).toEqual(1);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toEqual(
+      true
+    );
+  });
+
+  test('Total number of items conditions is  not met, using between', () => {
+    const item1 = { pieces: 1, itemId: '1', price: 100, modifiers: [] };
+    const item2 = { pieces: 1, itemId: '2', price: 100, modifiers: [] };
+    const item3 = { pieces: 1, itemId: '3', price: 100, modifiers: [] };
+    const item4 = { pieces: 1, itemId: '4', price: 100, modifiers: [] };
+
+    const order = {
+      id: 'ord-123',
+      items: [item1, item2, item3, item4],
+      modifiers: [],
+    };
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'totalNumberOfItems',
+            value: {
+              from: 5,
+              to: 15,
+            },
+            operand: '$between',
+          },
+        ],
+      },
+    };
+    const { addItemModifier } = pricingService.order;
+    const calculatedOrder = pricingService.order.calculate(
+      addItemModifier({
+        order,
+        modifier,
+        itemIndex: 0,
+      })
+    );
+    expect(calculatedOrder.items[0].modifiers.length).toEqual(1);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toEqual(
+      false
+    );
+  });
+
+  test('Total number of items conditions is met, using gt', () => {
+    const item1 = { pieces: 1, itemId: '1', price: 100, modifiers: [] };
+    const item2 = { pieces: 1, itemId: '2', price: 100, modifiers: [] };
+    const item3 = { pieces: 1, itemId: '3', price: 100, modifiers: [] };
+    const item4 = { pieces: 1, itemId: '4', price: 100, modifiers: [] };
+
+    const order = {
+      id: 'ord-123',
+      items: [item1, item2, item3, item4],
+      modifiers: [],
+    };
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'totalNumberOfItems',
+            value: 2,
+            operand: '$gt',
+          },
+        ],
+      },
+    };
+    const { addItemModifier } = pricingService.order;
+    const calculatedOrder = pricingService.order.calculate(
+      addItemModifier({
+        order,
+        modifier,
+        itemIndex: 0,
+      })
+    );
+    expect(calculatedOrder.items[0].modifiers.length).toEqual(1);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toEqual(
+      true
+    );
+  });
+
+  test('Total number of items conditions is not met, using gt', () => {
+    const item1 = { pieces: 1, itemId: '1', price: 100, modifiers: [] };
+    const item2 = { pieces: 1, itemId: '2', price: 100, modifiers: [] };
+    const item3 = { pieces: 1, itemId: '3', price: 100, modifiers: [] };
+    const item4 = { pieces: 1, itemId: '4', price: 100, modifiers: [] };
+
+    const order = {
+      id: 'ord-123',
+      items: [item1, item2, item3, item4],
+      modifiers: [],
+    };
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'totalNumberOfItems',
+            value: 6,
+            operand: '$gt',
+          },
+        ],
+      },
+    };
+    const { addItemModifier } = pricingService.order;
+    const calculatedOrder = pricingService.order.calculate(
+      addItemModifier({
+        order,
+        modifier,
+        itemIndex: 0,
+      })
+    );
+    expect(calculatedOrder.items[0].modifiers.length).toEqual(1);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toEqual(
+      false
+    );
+  });
 });

package/lib/modifier/areConditionsMet.js

@@ -26,6 +26,11 @@ module.exports = ({ actions, utils }) => {
     modifier.conditions && Array.isArray(modifier.conditions.rules)
       ? modifier.conditions.rules.every(condition => {
           switch (condition.key) {
+            case 'totalNumberOfItems':
+              return actions.validateNumberCondition({
+                value: Array.isArray(allItems) ? allItems.length : 0,
+                condition,
+              });
             case 'itemSet': {
               if (!Array.isArray(allItems)) return true;
               const conditionValue = Number(condition.value.itemSet || 0);
@@ -84,31 +89,27 @@ module.exports = ({ actions, utils }) => {
               );
             }
             case 'itemPieces':
-              return actions.validateNumberCondition(
-                item.pieces,
-                condition.value,
-                condition.operand
-              );
+              return actions.validateNumberCondition({
+                value: item.pieces,
+                condition,
+              });
             case 'itemQuantity':
-              return actions.validateNumberCondition(
-                item.quantity,
-                condition.value,
-                condition.operand
-              );
+              return actions.validateNumberCondition({
+                value: item.quantity,
+                condition,
+              });
             case 'customerTotalVisits':
               if (!actions.isValidCustomer(customer)) return false;
-              return actions.validateNumberCondition(
-                getCustomerStat(customer, 'totalVisits'),
-                condition.value,
-                condition.operand
-              );
+              return actions.validateNumberCondition({
+                value: getCustomerStat(customer, 'totalVisits'),
+                condition,
+              });
             case 'customerTotalSales':
               if (!actions.isValidCustomer(customer)) return false;
-              return actions.validateNumberCondition(
-                getCustomerStat(customer, 'totalSales'),
-                condition.value,
-                condition.operand
-              );
+              return actions.validateNumberCondition({
+                value: getCustomerStat(customer, 'totalSales'),
+                condition,
+              });
             case 'modifiers':
               return actions.validateRequiredModifiers(
                 item.modifiers,

package/lib/modifier/index.js

@@ -176,6 +176,7 @@ const unlockCustomerStatsModifiers = require('./unlockCustomerStatsModifiers');
 const isAutoSplit = require('./isAutoSplit');
 const isKeepRelatedItems = require('./isKeepRelatedItems');
 const isSplitDepartment = require('./isSplitDepartment');
+const isModifierValid = require('./isModifierValid');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -365,6 +366,7 @@ const modifierActions = (deps = {}) => {
     isAutoSplit: isAutoSplit(innerDeps),
     isKeepRelatedItems: isKeepRelatedItems(innerDeps),
     isSplitDepartment: isSplitDepartment(innerDeps),
+    isModifierValid: isModifierValid(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isModifierValid.js

@@ -0,0 +1,11 @@
+module.exports = ({ actions }) =>
+  function isModifierValid(modifier) {
+    // Promotion modifiers
+    if (actions.isPromotion(modifier)) {
+      return actions.isAvailablePromotion(modifier);
+    }
+
+    // Add more modifier checks here ...
+
+    return true;
+  };

package/lib/modifier/validateNumberCondition.js

@@ -1,19 +1,33 @@
 module.exports = () =>
-  function validateNumberCondition(itemNumber, conditionNumber, operand) {
-    if (!conditionNumber && !operand) return true;
+  function validateNumberCondition({ value, condition }) {
+    const { operand } = condition;
+
+    const conditionValue = condition.value;
+
+    const fromValue =
+      typeof condition.value === 'object' ? condition.value.from : 0;
+
+    const toValue =
+      typeof condition.value === 'object' ? condition.value.to : 0;
+
+    if (!conditionValue && !operand) return true;
     switch (operand) {
       case '$eq':
-        return Number(conditionNumber) === itemNumber;
+        return Number(conditionValue) === value;
       case '$ne':
-        return Number(conditionNumber) !== itemNumber;
+        return Number(conditionValue) !== value;
       case '$gt':
-        return Number(conditionNumber) < itemNumber;
+        return Number(conditionValue) < value;
       case '$gte':
-        return Number(conditionNumber) <= itemNumber;
+        return Number(conditionValue) <= value;
       case '$lt':
-        return Number(conditionNumber) > itemNumber;
+        return Number(conditionValue) > value;
       case '$lte':
-        return Number(conditionNumber) >= itemNumber;
+        return Number(conditionValue) >= value;
+      case '$between':
+        return (
+          Number(value) >= Number(fromValue) && Number(value) <= Number(toValue)
+        );
       default:
         return false;
     }

package/lib/order/addItemModifier.js

@@ -16,8 +16,15 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
         item: itemProp,
       })
     ) {
-      onError('modifier.has.reached.the.maximum.amount.of.applies');
+      if (onError)
+        onError('modifier.has.reached.the.maximum.amount.of.applies');
+
+      return itemProp;
+    }
 
+    // Check if Modifier is Valid/Available
+    if (!modifierActions.isModifierValid(_modifier)) {
+      if (onError) onError('modifier.has.reached.the.maximum.of.uses');
       return itemProp;
     }
 
@@ -46,7 +53,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     modifier,
     itemIndex,
     originalItem,
-    onError,
+    onError = () => {},
   }) {
     let order = _.cloneDeep(orderProp);
     if (!order || itemIndex < 0 || !modifier) return order;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.110",
+  "version": "1.0.111",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -55,5 +55,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "3e47ebde1cb164b785b001a37853316ec3c8e352"
+  "gitHead": "b12a6c9aef83deec91c4ebe365bd9d604a0eecdd"
 }