@darkpos/pricing 1.0.4 → 1.0.7

package/__TEST__/modifier/sort.test.js

@@ -0,0 +1,41 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('Sort Function', () => {
+  test('usecase #1', () => {
+    const modifiers = [
+      {
+        _id: 1,
+        type: 'fixed',
+        action: 'add',
+        amount: 10,
+        name: 'someModifier',
+        properties: {},
+      },
+      {
+        _id: 2,
+        type: 'fixed',
+        action: 'add',
+        amount: 10,
+        name: 'someModifier',
+        properties: {
+          sort: 2,
+        },
+      },
+      {
+        _id: 3,
+        type: 'fixed',
+        action: 'add',
+        amount: 10,
+        name: 'someModifier',
+        properties: {
+          sort: 1,
+        },
+      },
+    ];
+    const sortedModifiers = pricingService.modifier.sort(modifiers);
+    const ids = sortedModifiers.map((mob) => mob._id);
+    expect(ids).toMatchObject([1, 3, 2]);
+  });
+});

package/__TEST__/order.test.js

@@ -1,90 +1,137 @@
-const orderActions = require('../lib/order/actions');
+const usePricing = require('../index');
+
+const pricingService = usePricing();
 
 describe('Order actions', () => {
   test('Get calculated Order, one item', () => {
     const modifiers = [
-      { amount: 20, type: 'percentage', action: 'add' },
-      { amount: 20, type: 'percentage', action: 'subtract' },
-      { amount: 2, type: 'fixed', action: 'subtract' },
+      {
+        compute: {
+          amount: 20,
+          type: 'percentage',
+          action: 'add',
+        },
+        name: 'modifier1',
+        type: 'discount',
+      },
+      {
+        compute: {
+          amount: 20,
+          type: 'percentage',
+          action: 'subtract',
+        },
+        name: 'modifier2',
+        type: 'discount',
+      },
+      {
+        compute: { amount: 2, type: 'fixed', action: 'subtract' },
+        name: 'modifier3',
+        type: 'discount',
+      },
     ];
     const orderItem = { price: 30, quantity: 2, modifiers };
     const order = { items: [orderItem] };
-    const newOrder = orderActions.calculateOrder(order);
+    const newOrder = pricingService.order.calculate(order);
+
     expect(newOrder).toHaveProperty('total', 56);
     expect(newOrder).toHaveProperty('subTotal', 60);
-    expect(newOrder).toHaveProperty('tax', 0);
-    expect(newOrder).toHaveProperty('discount', 0);
-    expect(newOrder).toHaveProperty('fee', -4);
-    expect(newOrder).toHaveProperty('distributed', 0);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -4,
+    });
   });
   test('Get calculated Order, multiple items', () => {
     const item1 = {
       _id: 1,
       price: 30,
       quantity: 2,
-      modifiers: [{ amount: 2, type: 'fixed', action: 'subtract' }],
+      modifiers: [
+        {
+          compute: {
+            amount: 2,
+            type: 'fixed',
+            action: 'subtract',
+          },
+          name: 'modifier1',
+          type: 'discount',
+        },
+      ],
     };
     const item2 = {
       _id: 2,
       price: 10,
       quantity: 1,
-      modifiers: [{ amount: 2, type: 'fixed', action: 'subtract' }],
+      modifiers: [
+        {
+          compute: {
+            amount: 2,
+            type: 'fixed',
+            action: 'subtract',
+          },
+          name: 'modifier1',
+          type: 'discount',
+        },
+      ],
     };
     const order = { items: [item1, item2] };
-    const newOrder = orderActions.calculateOrder(order);
+    const newOrder = pricingService.order.calculate(order);
     expect(newOrder).toHaveProperty('total', 64);
     expect(newOrder).toHaveProperty('subTotal', 70);
-    expect(newOrder).toHaveProperty('tax', 0);
-    expect(newOrder).toHaveProperty('discount', 0);
-    expect(newOrder).toHaveProperty('fee', -6);
-    expect(newOrder).toHaveProperty('distributed', 0);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -6,
+    });
+    // console.log(JSON.stringify(newOrder, 0, 2));
   });
-  test('Get calculated Order, multiple items and discount modifiers', () => {
+  test('Get calculated Order, multiple items and indirect modifiers', () => {
     const item1 = {
       _id: 1,
       price: 30,
       quantity: 2,
-      modifiers: [{ amount: 2, type: 'fixed', action: 'subtract', attributes: ['discount'] }],
     };
     const item2 = {
       _id: 2,
       price: 10,
       quantity: 1,
-      modifiers: [{ amount: 2, type: 'fixed', action: 'subtract', attributes: ['discount'] }],
     };
-    const order = { items: [item1, item2] };
-    const newOrder = orderActions.calculateOrder(order);
-    expect(newOrder).toHaveProperty('total', 64);
-    expect(newOrder).toHaveProperty('subTotal', 70);
-    expect(newOrder).toHaveProperty('tax', 0);
-    expect(newOrder).toHaveProperty('discount', -6);
-    expect(newOrder).toHaveProperty('fee', 0);
-    expect(newOrder).toHaveProperty('distributed', 0);
-  });
-  test('Get calculated Order, multiple items and distributed modifiers', () => {
-    const item1 = {
-      _id: 1,
-      price: 30,
-      quantity: 2,
-    };
-    const item2 = {
-      _id: 2,
-      price: 10,
-      quantity: 1,
+    const modifier1 = {
+      compute: {
+        amount: 2,
+        type: 'fixed',
+        action: 'subtract',
+      },
+      name: 'modifier1',
+      type: 'discount',
     };
-    const modifier1 = { amount: 2, type: 'fixed', action: 'subtract', attributes: ['discount'] };
 
     const order = { items: [item1, item2], modifiers: [modifier1] };
-    const newOrder = orderActions.calculateOrder(order);
 
+    const newOrder = pricingService.order.calculate(order);
     expect(newOrder).toHaveProperty('total', 68);
     expect(newOrder).toHaveProperty('subTotal', 70);
-    expect(newOrder).toHaveProperty('tax', 0);
-    expect(newOrder).toHaveProperty('discount', 0);
-    expect(newOrder).toHaveProperty('fee', 0);
-    expect(newOrder).toHaveProperty('distributed', -2);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -2,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 58.28);
+    expect(newOrder.items[0]).toHaveProperty('subTotals', {
+      discount: -1.72,
+      _included: 0,
+      _xincluded: -1.72,
+      _direct: 0,
+      _xdirect: -1.72,
+      _simple: 60,
+      _actual: 60,
+    });
+    expect(newOrder.items[1]).toHaveProperty('total', 9.72);
+    expect(newOrder.items[1]).toHaveProperty('subTotals', {
+      discount: -0.28,
+      _included: 0,
+      _xincluded: -0.28,
+      _direct: 0,
+      _xdirect: -0.28,
+      _simple: 10,
+      _actual: 10,
+    });
   });
-  test('Get calculated Order, multiple items and distributed modifiers #2', () => {
+  test('Get calculated Order, multiple items and indirect modifiers #2', () => {
     const item1 = {
       _id: 1,
       price: 15.99,
@@ -96,23 +143,44 @@ describe('Order actions', () => {
       quantity: 1,
     };
     const modifier1 = {
-      amount: 10,
-      type: 'percentage',
-      action: 'subtract',
-      attributes: ['discount'],
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'percentage',
+      },
+      name: 'modifier1',
+      type: 'discount',
     };
 
     const order = { items: [item1, item2], modifiers: [modifier1] };
-    const newOrder = orderActions.calculateOrder(order);
-
+    const newOrder = pricingService.order.calculate(order);
     expect(newOrder).toHaveProperty('total', 18.58);
     expect(newOrder).toHaveProperty('subTotal', 20.64);
-    expect(newOrder).toHaveProperty('tax', 0);
-    expect(newOrder).toHaveProperty('discount', 0);
-    expect(newOrder).toHaveProperty('fee', 0);
-    expect(newOrder).toHaveProperty('distributed', -2.06);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -2.06,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 14.39);
+    expect(newOrder.items[0]).toHaveProperty('subTotals', {
+      discount: -1.6,
+      _included: 0,
+      _xincluded: -1.6,
+      _direct: 0,
+      _xdirect: -1.6,
+      _simple: 15.99,
+      _actual: 15.99,
+    });
+    expect(newOrder.items[1]).toHaveProperty('total', 4.19);
+    expect(newOrder.items[1]).toHaveProperty('subTotals', {
+      discount: -0.46,
+      _included: 0,
+      _xincluded: -0.46,
+      _direct: 0,
+      _xdirect: -0.46,
+      _simple: 4.65,
+      _actual: 4.65,
+    });
   });
-  test('Get calculated Order, multiple items and distributed modifiers #3', () => {
+  test('Get calculated Order, multiple items and indirect modifiers #3', () => {
     const item1 = {
       _id: 1,
       price: 3,
@@ -130,31 +198,36 @@ describe('Order actions', () => {
     };
     const modifier1 = {
       _id: 1,
+      compute: {
+        amount: 10,
+        type: 'percentage',
+        action: 'subtract',
+      },
       name: `10% Discount`,
-      amount: 10,
-      type: 'percentage',
-      action: 'subtract',
-      attributes: ['discount'],
+      type: 'discount',
     };
 
     const modifier2 = {
       _id: 2,
-      name: `20% Discount`,
-      amount: 20,
-      type: 'percentage',
-      action: 'subtract',
-      attributes: ['discount'],
+      name: `20% tax`,
+      type: 'tax',
+      compute: {
+        amount: 20,
+        type: 'percentage',
+        action: 'add',
+      },
     };
 
-    const order = { items: [item1, item2, item3], modifiers: [modifier1, modifier2] };
-    const newOrder = orderActions.calculateOrder(order);
-
-    //console.log('order =>', JSON.stringify(newOrder, 0, 2));
-    expect(newOrder).toHaveProperty('total', 7);
+    const order = {
+      items: [item1, item2, item3],
+      modifiers: [modifier1, modifier2],
+    };
+    const newOrder = pricingService.order.calculate(order);
+    expect(newOrder).toHaveProperty('total', 11);
     expect(newOrder).toHaveProperty('subTotal', 10);
-    expect(newOrder).toHaveProperty('tax', 0);
-    expect(newOrder).toHaveProperty('discount', 0);
-    expect(newOrder).toHaveProperty('fee', 0);
-    expect(newOrder).toHaveProperty('distributed', -3);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -1,
+      tax: 2,
+    });
   });
 });

package/index.js

@@ -1,9 +1 @@
-const modifier = require('./lib/modifier');
-const item = require('./lib/item');
-const order = require('./lib/order');
-
-module.exports = {
-  modifier,
-  item,
-  order,
-};
+module.exports = require('./lib');

package/lib/constants/Modifier/Attributes.js

@@ -0,0 +1,9 @@
+//
+module.exports = {
+  SUBSCRIPTION: 'subscription',
+  PROMOTION: 'promotion',
+  GROUP: 'group',
+  LIST: 'list',
+  DEPARTMENT: 'department',
+  OVERRIDE: 'override',
+};

package/lib/constants/Modifier/Compute.js

@@ -0,0 +1,15 @@
+const Types = {
+  FIXED: 'fixed',
+  PERCENTAGE: 'percentage',
+};
+
+const Actions = {
+  ADD: 'add',
+  SUBTRACT: 'subtract',
+  OVERRIDE: 'override',
+};
+
+module.exports = {
+  Types,
+  Actions,
+};

package/lib/constants/Modifier/Types.js

@@ -0,0 +1,7 @@
+//
+module.exports = {
+  DISCOUNT: 'discount',
+  TAX: 'tax',
+  GRATUITY: 'gratuity',
+  CREDIT: 'credit',
+};

package/lib/constants/Modifier/index.js

@@ -0,0 +1,9 @@
+const Compute = require('./Compute');
+const Types = require('./Types');
+const Attributes = require('./Attributes');
+
+module.exports = {
+  Attributes,
+  Types,
+  Compute,
+};

package/lib/constants/Status.js

@@ -0,0 +1,39 @@
+const Order = Object.freeze({
+  OPEN: 'open',
+  HOLD: 'hold',
+  VOID: 'void',
+  CLOSED: 'close',
+});
+
+const Invoice = Object.freeze({
+  PARTIAL: 'partial',
+  PENDING: 'pending',
+  CLOSED: 'close',
+});
+
+const Kitchen = Object.freeze({
+  OPEN: 'open',
+  CLOSED: 'closed',
+});
+
+const Delivery = Object.freeze({
+  NONE: 'none',
+  BOOKED: 'booked',
+  PICKED: 'picked',
+  DELIVER: 'deliver',
+  DELIVERED: 'delivered',
+  DELIVERED_PARTIAL: 'delivered.partial',
+  RETURNED: 'returned',
+  RETURNED_PARTIAL: 'returned.partial',
+  HELD_NOT_READY: 'held.not.ready',
+  HELD_FOR_RELEASE_APPROVAL: 'held.for.release.approval',
+  CANCELLED: 'cancelled',
+  LOST: 'lost',
+});
+
+module.exports = Object.freeze({
+  Order,
+  Invoice,
+  Kitchen,
+  Delivery,
+});

package/lib/constants/index.js

@@ -0,0 +1,7 @@
+const Status = require('./Status');
+const Modifier = require('./Modifier');
+
+module.exports = {
+  Status,
+  Modifier,
+};

package/lib/index.js

@@ -0,0 +1,38 @@
+const utils = require('@darkpos/utils');
+const _ = require('lodash');
+const moment = require('moment-timezone');
+/** services  */
+const makeItemActions = require('./item');
+const makeOrderActions = require('./order');
+const makeModifierActions = require('./modifier');
+const constants = require('./constants');
+
+module.exports = session => {
+  const { useLocalization } = utils;
+  const settings = _.get(session, 'store._settings', {});
+  const localization = useLocalization(settings.localization);
+
+  const deps = {
+    settings,
+    utils,
+    localization,
+    _,
+    moment,
+    constants,
+  };
+
+  //
+  const modifierActions = makeModifierActions(deps);
+  const itemActions = makeItemActions({ ...deps, modifierActions });
+  const orderActions = makeOrderActions({
+    ...deps,
+    itemActions,
+    modifierActions,
+  });
+
+  return {
+    item: itemActions,
+    order: orderActions,
+    modifier: modifierActions,
+  };
+};

package/lib/item/addIndirectModifier.js

@@ -0,0 +1,55 @@
+module.exports = ({ utils, modifierActions }) => {
+  const { math } = utils;
+
+  return function addIndirectModifier(orderTotal, items, modifier) {
+    const itemsModifiers = {};
+    // get distributed price in order level
+    const { _computed } = modifierActions.calculate(modifier, {
+      price: orderTotal,
+      quantity: 1,
+    });
+
+    const orderModifierTotal = math.abs(_computed.amount);
+    const totalDistributed = items.reduce((acc, item) => {
+      const inheritedModifier = modifierActions.createIndirectModifier(
+        modifier,
+        {
+          orderTotal,
+          itemTotal: item.total,
+          itemQuantity: item.quantity,
+        }
+      );
+      itemsModifiers[item._id] = inheritedModifier;
+      return math.add(
+        acc,
+        math.mul(inheritedModifier.compute.amount, item.quantity)
+      );
+    }, 0);
+
+    // check validation
+    if (math.abs(totalDistributed) !== math.abs(orderModifierTotal)) {
+      const difference = math.sub(orderModifierTotal, totalDistributed);
+      // console.log('difference => ', difference);
+      const selectedItem = items.find(
+        item => math.sub(item.total, difference) > 0
+      );
+
+      if (selectedItem) {
+        const inheritedModifier = itemsModifiers[selectedItem._id];
+        itemsModifiers[selectedItem._id] = {
+          ...inheritedModifier,
+          compute: {
+            ...inheritedModifier.compute,
+            amount: math.add(
+              inheritedModifier.compute.amount,
+              math.div(difference, selectedItem.quantity)
+            ),
+          },
+        };
+      }
+      return itemsModifiers;
+    }
+
+    return itemsModifiers;
+  };
+};

package/lib/item/calculate.js

@@ -0,0 +1,108 @@
+/* eslint-disable no-restricted-syntax */
+module.exports = ({ _, utils, modifierActions }) => {
+  const { math } = utils;
+  //
+  const calculateOne = inputItem => {
+    const item = _.cloneDeep(inputItem);
+    if (!item) return item;
+
+    const subTotals = {
+      _included: 0,
+      _xincluded: 0,
+      _direct: 0,
+      _xdirect: 0,
+      _simple: 0,
+      _actual: 0,
+    };
+
+    const price = parseFloat(item.price);
+    const quantity = parseInt(item.quantity, 10);
+    subTotals._simple = math.mul(price, quantity);
+
+    const modifiers = [];
+    const { modifiers: itemModifiers = [] } = item;
+    const amountOverride = itemModifiers.find(each =>
+      modifierActions.isAmountOverride(each)
+    );
+
+    const modifiersToCompute = itemModifiers.filter(
+      each =>
+        !modifierActions.isOverride(each) && each.compute && each.compute.type
+    );
+    if (amountOverride) modifiersToCompute.push(amountOverride);
+
+    const modifiersToNotCompute = itemModifiers
+      .filter(
+        each =>
+          !modifiersToCompute.find(
+            ceach => ceach.modifierId === each.modifierId
+          )
+      )
+      .map(each => modifierActions.calculate(each, { skip: true }));
+
+    if (modifiersToCompute.length) {
+      // sort modifiers based on sort
+      const sortedModifiers = modifierActions.sort(modifiersToCompute);
+      let computedPrice = price;
+      let prvPrice = 0;
+      let prvSort;
+
+      for (const modifier of sortedModifiers) {
+        const included = modifierActions.isIncluded(modifier);
+        const direct = modifierActions.isDirect(modifier);
+        const sort = modifierActions.getProperty(modifier, 'sort');
+        // check if add amount to computedPrice;
+        if (sort !== prvSort) {
+          computedPrice = math.add(computedPrice, prvPrice);
+          prvPrice = 0;
+          prvSort = null;
+        }
+
+        const _modifier = modifierActions.calculate(modifier, {
+          price: computedPrice,
+          quantity,
+          skip: !!amountOverride,
+        });
+
+        modifiers.push(_modifier);
+        const { type, _computed } = _modifier;
+        // console.log('computedPrice => ', _computed);
+        let computedAmount = math.mul(_computed.amount, quantity);
+        // subscription modifiers have fixed amount and can't be multiplied by quantity
+        if (modifierActions.isSubscription(_modifier))
+          computedAmount = _computed.amount;
+
+        if (included) {
+          subTotals._included = math.add(subTotals._included, computedAmount);
+          prvPrice = math.add(prvPrice, computedAmount);
+          prvSort = sort;
+        } else {
+          subTotals._xincluded = math.add(subTotals._xincluded, computedAmount);
+          subTotals[type] = math.add(subTotals[type] || 0, computedAmount);
+        }
+        if (direct)
+          subTotals._direct = math.add(subTotals._direct, computedAmount);
+        else subTotals._xdirect = math.add(subTotals._xdirect, computedAmount);
+      }
+    }
+
+    subTotals._actual = math.add(subTotals._simple, subTotals._included);
+    // console.log('subTotals =>', subTotals);
+    const total = math.add(subTotals._actual, subTotals._xincluded);
+
+    return {
+      ...item,
+      modifiers: [...modifiersToNotCompute, ...modifiers],
+      subTotals,
+      total,
+    };
+  };
+
+  //
+  const calculateMany = (items = []) => items.map(item => calculateOne(item));
+
+  return function calculate(item) {
+    if (Array.isArray(item)) return calculateMany(item);
+    return calculateOne(item);
+  };
+};

package/lib/item/create.js

@@ -0,0 +1,35 @@
+module.exports = ({ utils }) => {
+  const { helpers } = utils;
+
+  const defaultItem = {
+    location: {},
+    status: {
+      picked: { value: false, date: '' },
+      paid: { value: false, date: '' },
+      tracker: [],
+    },
+    name: '',
+    description: '',
+    pieces: 0,
+    modifiersTotalAmount: 0,
+    total: 0,
+    totalPaid: 0,
+    price: 0,
+    quantity: 0,
+    path: [],
+    notes: [],
+    menuId: null,
+    serial: null,
+    sku: null,
+    modifiers: [],
+  };
+
+  return function create(params) {
+    return {
+      ...defaultItem,
+      ...params,
+      __typename: 'OrderItem',
+      _id: helpers.getObjectID(),
+    };
+  };
+};