@darkpos/pricing 1.0.41 → 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

@@ -1,22 +1,55 @@
-module.exports = ({ modifierActions }) =>
+module.exports = ({ modifierActions, _, settings }) =>
   function getItemModifiersDescription(item) {
+    const groupModifiers =
+      settings && settings.order && settings.order.groupModifiers;
     if (!item || !Array.isArray(item.modifiers)) return [];
-    const description = item.modifiers
+    let description = item.modifiers
       .filter(
         each =>
           !modifierActions.isHidden(each) &&
+          modifierActions.isValid(each) &&
           !modifierActions.isAmountOverride(each) &&
+          !modifierActions.isDepartment(each) &&
           modifierActions.isDirect(each)
       )
       .map(modifier => {
-        const { name } = modifier;
+        const { name, _id, compute = {} } = modifier;
         let label = name;
         if (modifierActions.isGroupOfValues(modifier))
           label = modifierActions.getSelectedValues(modifier) || label;
+        const selectedOverrideOptions = _.get(
+          modifier,
+          'properties.override.selected'
+        );
+        if (
+          modifier &&
+          !modifier.included &&
+          modifier._computed &&
+          modifier._computed.description
+        ) {
+          label = modifier._computed.description;
+        }
 
-        return label;
-      })
-      .join(', ');
+        const modifierValue = {
+          label,
+          value: _id,
+          data: modifier,
+          quantity: 1,
+        };
 
-    return description;
+        if (selectedOverrideOptions) {
+          modifierValue.label = `${name} ${compute.amount} ${selectedOverrideOptions.selectedUnit}`;
+          modifierValue.quantity = 0;
+        }
+        return modifierValue;
+      });
+    if (groupModifiers) {
+      description = modifierActions.getGroupedModifiers(description);
+    }
+
+    const descriptions = modifierActions.getNotesToModifierTags({
+      notes: item.notes,
+      modifierTags: description,
+    });
+    return descriptions;
   };

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/getGroupedModifierLabels.js

@@ -0,0 +1,10 @@
+module.exports = ({ actions }) =>
+  function getGroupedModifierLabels(modifiers) {
+    const gModifiers = modifiers.map(modifier => ({
+      label: modifier.name,
+      value: modifier.modifierId,
+      data: modifier,
+      quantity: 1,
+    }));
+    return actions.getGroupedModifiers(gModifiers).map(tag => tag.label);
+  };

package/lib/modifier/getGroupedModifiers.js

@@ -0,0 +1,21 @@
+module.exports = () =>
+  function getGroupedModifiers(tags) {
+    return tags
+      .reduce((acc, curr) => {
+        const found = acc.find(
+          item => item.data.modifierId === curr.data.modifierId
+        );
+
+        if (found) {
+          found.quantity += 1;
+        } else {
+          acc.push({ ...curr });
+        }
+
+        return acc;
+      }, [])
+      .map(tag => ({
+        ...tag,
+        label: `${tag.quantity} ${tag.label}`,
+      }));
+  };

package/lib/modifier/getNotesToModifierTags.js

@@ -0,0 +1,21 @@
+module.exports = () =>
+  function getNotesToModifierTags({ notes, modifierTags }) {
+    let noteTags = [];
+    if (notes && notes.length > 0) {
+      noteTags =
+        notes
+          .filter(Boolean)
+          .filter(item => item && !item.url)
+          .map((note, index) => {
+            const { message } = note;
+            return {
+              label: message,
+              value: index.toString(),
+              data: note,
+              quantity: 1,
+            };
+          }) || [];
+    }
+
+    return modifierTags.concat(noteTags);
+  };