@darkpos/pricing 1.0.43 → 1.0.44

package/__TEST__/order/validateConditionsCalculate.test.js

@@ -0,0 +1,397 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('Conditions not met for the item', () => {
+  test('#1: Item pieces condition is not met, item price remains the same', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const item = {
+      quantity: 1,
+      pieces: 1,
+      itemId: '123',
+      price: 100,
+      modifiers: [
+        {
+          compute: {
+            amount: 30,
+            type: 'fixed',
+            action: 'substract',
+          },
+          conditions: {
+            rules: [
+              {
+                key: 'itemPieces',
+                value: 5,
+                operand: '$gt',
+              },
+            ],
+          },
+        },
+      ],
+    };
+    order.items.push(item);
+    const { calculate } = pricingService.order;
+    // Calculate the order
+    const calculatedOrder = calculate(order);
+    expect(calculatedOrder).toHaveProperty('total', 100);
+    expect(calculatedOrder).toHaveProperty('subTotal', 100);
+  });
+  test('#2: Item pieces condition is met, item total is updated', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const item = {
+      quantity: 1,
+      pieces: 6,
+      itemId: '123',
+      price: 100,
+      modifiers: [
+        {
+          compute: {
+            amount: 30,
+            type: 'fixed',
+            action: 'subtract',
+          },
+          conditions: {
+            rules: [
+              {
+                key: 'itemPieces',
+                value: 5,
+                operand: '$gt',
+              },
+            ],
+          },
+        },
+      ],
+    };
+    order.items.push(item);
+    const { calculate } = pricingService.order;
+    // Calculate the order
+
+    const calculatedOrder = calculate(order);
+    expect(calculatedOrder).toHaveProperty('total', 70);
+    expect(calculatedOrder).toHaveProperty('subTotal', 100);
+  });
+  test('#3: Required modifiers condition is not met, item price remains the same', () => {
+    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: [{ _id: 'mod-1' }],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        amount: 30,
+        type: 'fixed',
+        action: 'subtract',
+      },
+    };
+    item.modifiers.push(modifier);
+    const { calculate } = pricingService.order;
+    // Calculate the order
+    const calculatedOrder = calculate(order);
+    expect(calculatedOrder).toHaveProperty('total', 100);
+    expect(calculatedOrder).toHaveProperty('subTotal', 100);
+  });
+  test('#4: Required modifiers condition is met, item total is updated', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const item = {
+      quantity: 1,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    };
+    const modifierToValidate = {
+      _id: 'mod-1',
+    };
+
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'modifiers',
+            value: [{ modifierId: 'mod-1' }],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        amount: 30,
+        type: 'fixed',
+        action: 'subtract',
+      },
+    };
+    item.modifiers.push(modifierToValidate);
+    item.modifiers.push(modifier);
+    order.items.push(item);
+    const { calculate } = pricingService.order;
+    const calculatedOrder = calculate(order);
+    expect(calculatedOrder).toHaveProperty('total', 70);
+    expect(calculatedOrder).toHaveProperty('subTotal', 100);
+  });
+  test('#5: endDateDays condition is not met, item price remains the same', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+      start: {
+        requestDate: new Date('2020-01-01'),
+      },
+      end: {
+        requestDate: new Date('2020-01-02'),
+      },
+    };
+    const item = {
+      quantity: 1,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    };
+    order.items.push(item);
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'endDateDays',
+            value: 5,
+            operand: '$gt',
+          },
+        ],
+      },
+      compute: {
+        amount: 30,
+        type: 'fixed',
+        action: 'subtract',
+      },
+    };
+    item.modifiers.push(modifier);
+    const { calculate } = pricingService.order;
+    // Calculate the order
+    const calculatedOrder = calculate(order);
+    expect(calculatedOrder).toHaveProperty('total', 100);
+    expect(calculatedOrder).toHaveProperty('subTotal', 100);
+  });
+  test('#6: endDateDays condition is met, item total is updated', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+      start: {
+        requestDate: new Date('2020-01-01'),
+      },
+      end: {
+        requestDate: new Date('2020-01-08'),
+      },
+    };
+    const item = {
+      quantity: 1,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    };
+    order.items.push(item);
+    const modifier = {
+      compute: {
+        amount: 30,
+        type: 'fixed',
+        action: 'subtract',
+      },
+      conditions: {
+        rules: [
+          {
+            key: 'endDateDays',
+            value: 5,
+            operand: '$gt',
+          },
+        ],
+      },
+    };
+    item.modifiers.push(modifier);
+    const { calculate } = pricingService.order;
+    // Calculate the order
+    const calculatedOrder = calculate(order);
+    expect(calculatedOrder).toHaveProperty('total', 70);
+    expect(calculatedOrder).toHaveProperty('subTotal', 100);
+  });
+  // Do tests for paymentMethods and paymentTypes
+  test('#7: paymentMethods condition is not met, item price remains the same', () => {
+    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: 'paymentMethods',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        amount: 30,
+        type: 'fixed',
+        action: 'subtract',
+      },
+    };
+    item.modifiers.push(modifier);
+    const { calculate } = pricingService.order;
+    const paymentMethod = {
+      key: 'credit',
+    };
+    const calculatedOrder = calculate(order, { paymentMethod });
+    expect(calculatedOrder).toHaveProperty('total', 100);
+    expect(calculatedOrder).toHaveProperty('subTotal', 100);
+  });
+  test('#8: paymentMethods condition is met, item total is updated', () => {
+    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: 'paymentMethods',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        amount: 30,
+        type: 'fixed',
+        action: 'subtract',
+      },
+    };
+    item.modifiers.push(modifier);
+    const { calculate } = pricingService.order;
+    // Calculate the order
+    const paymentMethod = {
+      key: 'cash',
+    };
+    const calculatedOrder = calculate(order, { paymentMethod });
+    expect(calculatedOrder).toHaveProperty('total', 70);
+    expect(calculatedOrder).toHaveProperty('subTotal', 100);
+  });
+  test('#9: paymentTypes condition is not met, item price remains the same', () => {
+    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: 'paymentTypes',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        amount: 30,
+        type: 'fixed',
+        action: 'subtract',
+      },
+    };
+    item.modifiers.push(modifier);
+    const { calculate } = pricingService.order;
+    const paymentMethod = {
+      type: 'credit',
+    };
+    // Calculate the order
+    const calculatedOrder = calculate(order, { paymentMethod });
+    expect(calculatedOrder).toHaveProperty('total', 100);
+    expect(calculatedOrder).toHaveProperty('subTotal', 100);
+  });
+  test('#10: paymentTypes condition is met, item total is updated', () => {
+    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: 'paymentTypes',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        amount: 30,
+        type: 'fixed',
+        action: 'subtract',
+      },
+    };
+    item.modifiers.push(modifier);
+    const { calculate } = pricingService.order;
+    // Calculate the order
+    const paymentMethod = {
+      type: 'cash',
+    };
+    const calculatedOrder = calculate(order, { paymentMethod });
+    expect(calculatedOrder).toHaveProperty('total', 70);
+    expect(calculatedOrder).toHaveProperty('subTotal', 100);
+  });
+});

package/lib/constants/index.js

@@ -1,4 +1,4 @@
-const Status = require('./status');
+const Status = require('./Status');
 const Modifier = require('./Modifier');
 
 module.exports = {

package/lib/index.js

@@ -2,6 +2,7 @@ const utils = require('@darkpos/utils');
 const _ = require('lodash');
 const moment = require('moment-timezone');
 /** services  */
+const makeStoreActions = require('./store');
 const makeItemActions = require('./item');
 const makeOrderActions = require('./order');
 const makeModifierActions = require('./modifier');
@@ -22,18 +23,26 @@ module.exports = session => {
   };
 
   //
-  const modifierActions = makeModifierActions(deps);
-  const itemActions = makeItemActions({ ...deps, modifierActions });
+  // general actions
+  const storeActions = makeStoreActions(deps);
+  const modifierActions = makeModifierActions({ ...deps, storeActions });
+  const itemActions = makeItemActions({
+    ...deps,
+    modifierActions,
+    storeActions,
+  });
   const orderActions = makeOrderActions({
     ...deps,
     itemActions,
     modifierActions,
+    storeActions,
   });
 
   return {
     item: itemActions,
     order: orderActions,
     modifier: modifierActions,
+    store: storeActions,
     constants,
   };
 };

package/lib/item/calculate.js

@@ -3,9 +3,11 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
   const { math } = utils;
   //
   const { getComputeModField } = require('../modifier/utils');
-
-  const calculateOne = inputItem => {
+  const calculateOne = (inputItem, opts = {}) => {
     const item = _.cloneDeep(inputItem);
+    const paymentMethod = opts.paymentMethod || null;
+    const startRequestDate = opts.startRequestDate || null;
+    const endRequestDate = opts.endRequestDate || null;
     if (!item) return item;
 
     const subTotals = {
@@ -23,17 +25,31 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
 
     const modifiers = [];
     const { modifiers: itemModifiers = [] } = item;
-    const amountOverride = itemModifiers.find(each =>
+
+    const validatedModifiers = itemModifiers.map(each =>
+      modifierActions.validate(each, {
+        item,
+        paymentMethod,
+        startRequestDate,
+        endRequestDate,
+      })
+    );
+
+    const amountOverride = validatedModifiers.find(each =>
       modifierActions.isAmountOverride(each)
     );
 
-    const modifiersToCompute = itemModifiers.filter(
+    const modifiersToCompute = validatedModifiers.filter(
       each =>
-        !modifierActions.isOverride(each) && each.compute && each.compute.type
+        !modifierActions.isOverride(each) &&
+        each.compute &&
+        each.compute.type &&
+        modifierActions.isValid(each)
     );
+
     if (amountOverride) modifiersToCompute.push(amountOverride);
 
-    const modifiersToNotCompute = itemModifiers
+    const modifiersToNotCompute = validatedModifiers
       .filter(
         each =>
           !modifiersToCompute.find(
@@ -113,10 +129,11 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
   };
 
   //
-  const calculateMany = (items = []) => items.map(item => calculateOne(item));
+  const calculateMany = (items = [], opts = null) =>
+    items.map(item => calculateOne(item, opts));
 
-  return function calculate(item) {
-    if (Array.isArray(item)) return calculateMany(item);
-    return calculateOne(item);
+  return function calculate(item, opts) {
+    if (Array.isArray(item)) return calculateMany(item, opts);
+    return calculateOne(item, opts);
   };
 };

package/lib/item/getItemModifiersDescription.js

@@ -7,6 +7,7 @@ module.exports = ({ modifierActions, _, settings }) =>
       .filter(
         each =>
           !modifierActions.isHidden(each) &&
+          modifierActions.isValid(each) &&
           !modifierActions.isAmountOverride(each) &&
           !modifierActions.isDepartment(each) &&
           modifierActions.isDirect(each)

package/lib/item/markModifiersAsLocked.js

@@ -5,7 +5,9 @@ module.exports = () =>
     return {
       ...item,
       modifiers: item.modifiers.map(mod =>
-        modifierIds.includes(mod._parentId) ? { ...mod, locked: true } : mod
+        modifierIds.includes(mod._parentId || mod._id)
+          ? { ...mod, locked: true }
+          : mod
       ),
     };
   };

package/lib/modifier/areConditionsMet.js

@@ -0,0 +1,71 @@
+module.exports = ({ actions }) => {
+  const modifierConditionPass = (
+    modifier,
+    { item, paymentMethod, startRequestDate, endRequestDate }
+  ) =>
+    modifier.conditions && Array.isArray(modifier.conditions.rules)
+      ? modifier.conditions.rules.every(condition => {
+          switch (condition.key) {
+            case 'itemPieces':
+              return actions.validateNumberCondition(
+                item.pieces,
+                condition.value,
+                condition.operand
+              );
+            case 'itemQuantity':
+              return actions.validateNumberCondition(
+                item.quantity,
+                condition.value,
+                condition.operand
+              );
+            case 'modifiers':
+              return actions.validateRequiredModifiers(
+                item.modifiers,
+                condition.value,
+                condition.operand
+              );
+            case 'endDateDays':
+              return actions.validateDateDaysDiff(
+                startRequestDate,
+                endRequestDate,
+                condition.value,
+                condition.operand
+              );
+            case 'paymentMethods':
+              return actions.validateInArr(
+                paymentMethod ? paymentMethod.key : null,
+                condition.value,
+                condition.operand
+              );
+            case 'paymentTypes':
+              return actions.validateInArr(
+                paymentMethod ? paymentMethod.type : null,
+                condition.value,
+                condition.operand
+              );
+            default:
+              return false;
+          }
+        }) || modifier.locked
+      : true;
+
+  function areConditionsMet(modifier, opts) {
+    const {
+      item = null,
+      paymentMethod = null,
+      endRequestDate = null,
+      startRequestDate = null,
+    } = opts;
+    // const recommendedEndDate = storeActions.getRecommendedEndDate();
+    return (
+      modifier &&
+      modifierConditionPass(modifier, {
+        item,
+        paymentMethod,
+        startRequestDate,
+        endRequestDate,
+      })
+    );
+  }
+  return areConditionsMet;
+};

package/lib/modifier/index.js

@@ -19,8 +19,6 @@ const duplicate = require('./duplicate');
 const enableAutoPopup = require('./enableAutoPopup');
 const filterByRequiredModifiers = require('./filterByRequiredModifiers');
 const findById = require('./findById');
-const findByPaymentMethod = require('./findByPaymentMethod');
-const findByPaymentType = require('./findByPaymentType');
 const getAvailablePromotions = require('./getAvailablePromotions');
 const getAvailablePromotionsOrSubscriptions = require('./getAvailablePromotionsOrSubscriptions');
 const getAvailableSubscriptions = require('./getAvailableSubscriptions');
@@ -82,6 +80,7 @@ const isDirect = require('./isDirect');
 const hasNoTags = require('./hasNoTags');
 const isRemoveModifier = require('./isRemoveModifier');
 const isGroupOfModifiers = require('./isGroupOfModifiers');
+const areConditionsMet = require('./areConditionsMet');
 const isRequiredAndOverride = require('./isRequiredAndOverride');
 const isManual = require('./isManual');
 const isPriceOverride = require('./isPriceOverride');
@@ -102,6 +101,7 @@ const isDefault = require('./isDefault');
 const isIncluded = require('./isIncluded');
 const isCustomerTagsExtend = require('./isCustomerTagsExtend');
 const isAmountOverride = require('./isAmountOverride');
+const isValid = require('./isValid');
 const isDiscount = require('./isDiscount');
 const isHidden = require('./isHidden');
 const isIgnoreQuantity = require('./isIgnoreQuantity');
@@ -124,7 +124,6 @@ const isFixedAdd = require('./isFixedAdd');
 const isFee = require('./isFee');
 const isAdd = require('./isAdd');
 const mutateModifier = require('./mutateModifier');
-
 const isFixedDiscount = require('./isFixedDiscount');
 const removeLocked = require('./removeLocked');
 const hasItems = require('./hasItems');
@@ -133,6 +132,11 @@ const getGroupedModifiers = require('./getGroupedModifiers');
 const getNotesToModifierTags = require('./getNotesToModifierTags');
 const isOptionsOverride = require('./isOptionsOverride');
 const getGroupedModifierLabels = require('./getGroupedModifierLabels');
+const validate = require('./validate');
+const validateNumberCondition = require('./validateNumberCondition');
+const validateRequiredModifiers = require('./validateRequiredModifiers');
+const validateDateDaysDiff = require('./validateDateDaysDiff');
+const validateInArr = require('./validateInArr');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -163,8 +167,6 @@ const modifierActions = (deps = {}) => {
     enableAutoPopup: enableAutoPopup(innerDeps),
     filterByRequiredModifiers: filterByRequiredModifiers(innerDeps),
     findById: findById(innerDeps),
-    findByPaymentMethod: findByPaymentMethod(innerDeps),
-    findByPaymentType: findByPaymentType(innerDeps),
     getAvailablePromotions: getAvailablePromotions(innerDeps),
     getAvailablePromotionsOrSubscriptions:
       getAvailablePromotionsOrSubscriptions(innerDeps),
@@ -247,6 +249,7 @@ const modifierActions = (deps = {}) => {
     isDefault: isDefault(innerDeps),
     isCustomerTagsExtend: isCustomerTagsExtend(innerDeps),
     isAmountOverride: isAmountOverride(innerDeps),
+    isValid: isValid(innerDeps),
     isDiscount: isDiscount(innerDeps),
     isHidden: isHidden(innerDeps),
     isIgnoreQuantity: isIgnoreQuantity(innerDeps),
@@ -277,6 +280,12 @@ const modifierActions = (deps = {}) => {
     getNotesToModifierTags: getNotesToModifierTags(innerDeps),
     isOptionsOverride: isOptionsOverride(innerDeps),
     getGroupedModifierLabels: getGroupedModifierLabels(innerDeps),
+    validate: validate(innerDeps),
+    validateNumberCondition: validateNumberCondition(innerDeps),
+    validateRequiredModifiers: validateRequiredModifiers(innerDeps),
+    validateDateDaysDiff: validateDateDaysDiff(innerDeps),
+    validateInArr: validateInArr(innerDeps),
+    areConditionsMet: areConditionsMet(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isPaymentMethodModifier.js

@@ -3,6 +3,6 @@ module.exports = () =>
     return !!(
       modifier &&
       modifier.conditions &&
-      (modifier.conditions.paymentMethods || []).length > 0
+      modifier.conditions.some(condition => condition.key === 'paymentMethods')
     );
   };

package/lib/modifier/isPaymentTypeModifier.js

@@ -3,6 +3,6 @@ module.exports = () =>
     return !!(
       modifier &&
       modifier.conditions &&
-      (modifier.conditions.paymentTypes || []).length > 0
+      modifier.conditions.some(condition => condition.key === 'paymentTypes')
     );
   };

package/lib/modifier/isValid.js

@@ -0,0 +1,12 @@
+module.exports = () =>
+  function isValid(modifier) {
+    if (
+      !modifier ||
+      !modifier.conditions ||
+      modifier.conditions.valid === undefined ||
+      modifier.conditions.valid === null
+    )
+      return true;
+
+    return !!modifier.conditions.valid;
+  };