@darkpos/pricing 1.0.43 → 1.0.45

package/__TEST__/order/validateConditionsCalculate.test.js

@@ -0,0 +1,396 @@
+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: [],
+      total: 100,
+    };
+    order.items.push(item);
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'paymentMethods',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+        _id: 'abcd',
+        modifierId: '123',
+      },
+      compute: {
+        amount: 30,
+        type: 'fixed',
+        action: 'subtract',
+      },
+    };
+    item.modifiers.push(modifier);
+    const { calculate } = pricingService.order;
+    const calculatedOrder = calculate(order, { paymentType: 'credit' });
+    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: [],
+      total: 100,
+    };
+    order.items.push(item);
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'paymentMethods',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        amount: 30,
+        type: 'fixed',
+        action: 'subtract',
+      },
+      _id: '123',
+      modifierId: 'abc',
+    };
+    item.modifiers.push(modifier);
+    const { calculate } = pricingService.order;
+
+    const calculatedOrder = calculate(order, { paymentMethod: 'cash' });
+    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: [],
+    };
+    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',
+      },
+      _id: '111',
+      modifierId: 'ccc',
+    };
+    item.modifiers.push(modifier);
+    const { calculate } = pricingService.order;
+
+    // Calculate the order
+    const calculatedOrder = calculate(order, { paymentType: 'credit' });
+    expect(calculatedOrder).toHaveProperty('total', 100);
+    expect(calculatedOrder).toHaveProperty('subTotal', 100);
+  });
+  test('#10: paymentTypes condition is met, item total is updated', () => {
+    const item = {
+      quantity: 1,
+      itemId: '123',
+      price: 100,
+      modifiers: [
+        {
+          conditions: {
+            rules: [
+              {
+                key: 'paymentTypes',
+                value: ['cash'],
+                operand: '$in',
+              },
+            ],
+          },
+          compute: {
+            amount: 30,
+            type: 'fixed',
+            action: 'subtract',
+          },
+          _id: '123',
+          modifierId: 'bcd',
+        },
+      ],
+      total: 100,
+    };
+    const { calculate } = pricingService.order;
+
+    const calculatedOrder = calculate(
+      {
+        _id: 'ord-123',
+        items: [item],
+      },
+      { paymentType: 'cash' }
+    );
+    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

@@ -1,11 +1,20 @@
+const { getComputeModField } = require('../modifier/utils');
+
 /* eslint-disable no-restricted-syntax */
 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 amountToPay =
+      typeof opts.amountToPay === 'number' ? opts.amountToPay : 0;
+    const paymentMethod = opts.paymentMethod || null;
+    const paymentType = opts.paymentType || null;
+    const startRequestDate = opts.startRequestDate || null;
+    const endRequestDate = opts.endRequestDate || null;
+    const lockPaymentModifiers = !!opts.lockPaymentModifiers;
+    const { paymentId } = opts;
+
     if (!item) return item;
 
     const subTotals = {
@@ -23,28 +32,68 @@ 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,
+        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)
     );
+
+    const paymentModifiersToCompute = validatedModifiers
+      .filter(
+        modifier =>
+          modifierActions.isPaymentModifier(modifier) &&
+          modifierActions.hasPaymentMethodType({
+            paymentModifier: modifier,
+            paymentMethod,
+            paymentType,
+          })
+      )
+      .filter(paymentModifier => {
+        const childModifiers = modifierActions.getChildren({
+          parentModifier: paymentModifier,
+          modifiers: modifiersToCompute,
+        });
+
+        return (
+          !modifierActions.isFixed(paymentModifier) ||
+          childModifiers.length === 0
+        );
+      });
+
     if (amountOverride) modifiersToCompute.push(amountOverride);
 
-    const modifiersToNotCompute = itemModifiers
+    const modifiersToNotCompute = validatedModifiers
       .filter(
         each =>
+          modifierActions.isPaymentModifier(each) ||
           !modifiersToCompute.find(
             ceach => ceach.modifierId === each.modifierId
           )
       )
       .map(each => modifierActions.calculate(each, { skip: true }));
 
-    if (modifiersToCompute.length) {
+    if (modifiersToCompute.length || paymentModifiersToCompute.length) {
       // sort modifiers based on sort
-      const sortedModifiers = modifierActions.sort(modifiersToCompute);
+      const sortedModifiers = modifierActions.sort([
+        ...modifiersToCompute,
+        ...paymentModifiersToCompute,
+      ]);
+
       let computedPrice = price;
       let prvPrice = 0;
       let prvSort;
@@ -60,12 +109,37 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
           prvSort = null;
         }
 
-        const _modifier = modifierActions.calculate(modifier, {
-          price: computedPrice,
-          quantity,
-        });
+        let _modifier = modifier;
+
+        if (modifierActions.isPaymentModifier(modifier)) {
+          _modifier = modifierActions.calculatePaymentModifier({
+            paymentModifier: modifier,
+            amountToPay,
+            itemBalance:
+              typeof item.totalPaid === 'number' && item.totalPaid > 0
+                ? actions.getItemsBalance({ items: [item] })
+                : math.sub(computedPrice, item.totalPaid),
+            paymentMethod,
+            paymentType,
+            paymentId,
+          });
+        }
+
+        _modifier = modifierActions.calculate(
+          { ..._modifier },
+          {
+            price: computedPrice,
+            quantity,
+          }
+        );
+
+        if (
+          !modifierActions.isPaymentModifier(modifier) ||
+          lockPaymentModifiers
+        ) {
+          modifiers.push(_modifier);
+        }
 
-        modifiers.push(_modifier);
         const { type, _computed } = _modifier;
 
         const computedAmountCalc = math.mul(_computed.amount, quantity);
@@ -113,10 +187,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/getAmounts.js

@@ -0,0 +1,14 @@
+module.exports = ({ utils }) =>
+  function getAmounts(item, amount) {
+    const { status = {}, total, totalPaid } = item;
+    const totalDue = utils.math.sub(total, totalPaid);
+    const remainingAmount = utils.math.sub(amount, totalDue);
+
+    if (status && status.paid && status.paid.value)
+      return { amountToAssign: 0, remainingAmount: amount, isPaid: true };
+
+    if (amount >= totalDue)
+      return { amountToAssign: totalDue, remainingAmount, isPaid: true };
+
+    return { amountToAssign: amount, remainingAmount: 0, isPaid: false };
+  };

package/lib/item/getBalance.js

@@ -3,7 +3,6 @@ module.exports = ({ utils }) => {
   return function getBalance({ item }) {
     if (!item) return 0;
     if (Array.isArray(item)) return 0;
-
     return math.sub(item.total, item.totalPaid);
   };
 };

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

@@ -0,0 +1,9 @@
+module.exports = ({ utils, actions }) =>
+  function getItemsBalance({ items = [] }) {
+    const result = items.reduce(
+      (acc, item) => utils.math.add(acc, actions.getBalance({ item })),
+      0
+    );
+    console.log({ result });
+    return result;
+  };

package/lib/item/getItemsTotals.js

@@ -0,0 +1,27 @@
+/* eslint-disable no-restricted-syntax */
+
+module.exports = ({ utils }) => {
+  const { math } = utils;
+  return function getItemsTotals(items) {
+    const subTotals = {};
+    let subTotal = 0;
+    let total = 0;
+
+    for (const item of items) {
+      subTotal = math.add(subTotal, item.subTotals._actual);
+      const keys = Object.keys(item.subTotals).filter(
+        key => !key.includes('_')
+      );
+      for (const key of keys) {
+        subTotals[key] = math.add(subTotals[key], item.subTotals[key]);
+      }
+      total = math.add(total, item.total);
+    }
+
+    return {
+      subTotals,
+      subTotal,
+      total,
+    };
+  };
+};

package/lib/item/getTotal.js

@@ -2,6 +2,8 @@ module.exports = ({ utils }) => {
   const { math } = utils;
   return function getTotal(item) {
     if (!item || !item.subTotals) return 0;
-    return math.add(item.subTotals._actual, item.subTotals._xincluded);
+    return math.toDecimalPlaces(
+      math.add(item.subTotals._actual, item.subTotals._xincluded)
+    );
   };
 };

package/lib/item/hasPaymentMethodType.js

@@ -0,0 +1,17 @@
+module.exports = ({ modifierActions }) =>
+  function hasPaymentMethodType({ item, paymentMethod, paymentType }) {
+    if (
+      !item ||
+      !Array.isArray(item.modifiers) ||
+      (!paymentMethod && !paymentType)
+    )
+      return false;
+
+    return item.modifiers.some(modifier =>
+      modifierActions.hasPaymentMethodType({
+        paymentModifier: modifier,
+        paymentMethod,
+        paymentType,
+      })
+    );
+  };