@darkpos/pricing 1.0.5 → 1.0.8

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

@@ -6,25 +6,27 @@ describe('Order actions', () => {
   test('Get calculated Order, one item', () => {
     const modifiers = [
       {
-        amount: 20,
-        type: 'percentage',
-        action: 'add',
+        compute: {
+          amount: 20,
+          type: 'percentage',
+          action: 'add',
+        },
         name: 'modifier1',
-        category: 'discount',
+        type: 'discount',
       },
       {
-        amount: 20,
-        type: 'percentage',
-        action: 'subtract',
+        compute: {
+          amount: 20,
+          type: 'percentage',
+          action: 'subtract',
+        },
         name: 'modifier2',
-        category: 'discount',
+        type: 'discount',
       },
       {
-        amount: 2,
-        type: 'fixed',
-        action: 'subtract',
+        compute: { amount: 2, type: 'fixed', action: 'subtract' },
         name: 'modifier3',
-        category: 'discount',
+        type: 'discount',
       },
     ];
     const orderItem = { price: 30, quantity: 2, modifiers };
@@ -44,11 +46,13 @@ describe('Order actions', () => {
       quantity: 2,
       modifiers: [
         {
-          amount: 2,
-          type: 'fixed',
-          action: 'subtract',
+          compute: {
+            amount: 2,
+            type: 'fixed',
+            action: 'subtract',
+          },
           name: 'modifier1',
-          category: 'discount',
+          type: 'discount',
         },
       ],
     };
@@ -58,11 +62,13 @@ describe('Order actions', () => {
       quantity: 1,
       modifiers: [
         {
-          amount: 2,
-          type: 'fixed',
-          action: 'subtract',
+          compute: {
+            amount: 2,
+            type: 'fixed',
+            action: 'subtract',
+          },
           name: 'modifier1',
-          category: 'discount',
+          type: 'discount',
         },
       ],
     };
@@ -87,11 +93,13 @@ describe('Order actions', () => {
       quantity: 1,
     };
     const modifier1 = {
-      amount: 2,
-      type: 'fixed',
-      action: 'subtract',
+      compute: {
+        amount: 2,
+        type: 'fixed',
+        action: 'subtract',
+      },
       name: 'modifier1',
-      category: 'discount',
+      type: 'discount',
     };
 
     const order = { items: [item1, item2], modifiers: [modifier1] };
@@ -135,11 +143,13 @@ describe('Order actions', () => {
       quantity: 1,
     };
     const modifier1 = {
-      amount: 10,
-      action: 'subtract',
-      type: 'percentage',
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'percentage',
+      },
       name: 'modifier1',
-      category: 'discount',
+      type: 'discount',
     };
 
     const order = { items: [item1, item2], modifiers: [modifier1] };
@@ -188,20 +198,24 @@ describe('Order actions', () => {
     };
     const modifier1 = {
       _id: 1,
+      compute: {
+        amount: 10,
+        type: 'percentage',
+        action: 'subtract',
+      },
       name: `10% Discount`,
-      amount: 10,
-      type: 'percentage',
-      action: 'subtract',
-      category: 'discount',
+      type: 'discount',
     };
 
     const modifier2 = {
       _id: 2,
       name: `20% tax`,
-      amount: 20,
-      type: 'percentage',
-      action: 'add',
-      category: 'tax',
+      type: 'tax',
+      compute: {
+        amount: 20,
+        type: 'percentage',
+        action: 'add',
+      },
     };
 
     const order = {
@@ -215,6 +229,5 @@ describe('Order actions', () => {
       discount: -1,
       tax: 2,
     });
-    console.log('order =>', JSON.stringify(newOrder, 0, 2));
   });
 });

package/index.js

@@ -1,25 +1 @@
-const useModifierService = require('@darkpos/modifier');
-const utils = require('@darkpos/utils');
-const _ = require('lodash');
-/** services  */
-const makeItemService = require('./lib/item');
-const makeOrderService = require('./lib/order');
-
-module.exports = (deps = {}) => {
-  //
-  const modifierService = useModifierService(deps);
-
-  const itemService = makeItemService({ ...deps, _, utils, modifierService });
-  const orderService = makeOrderService({
-    ...deps,
-    _,
-    utils,
-    modifierService,
-    itemService,
-  });
-
-  return Object.freeze({
-    item: itemService,
-    order: orderService,
-  });
-};
+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/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/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

@@ -1,36 +1,53 @@
-module.exports = ({ utils, modifierService }) => {
+module.exports = ({ utils, modifierActions }) => {
   const { math } = utils;
 
-  return function addIndirectModifier(order, items, modifier) {
+  return function addIndirectModifier(orderTotal, items, modifier) {
     const itemsModifiers = {};
     // get distributed price in order level
-    const { computed } = modifierService.calculate(modifier, {
-      price: order.total,
+    const { _computed } = modifierActions.calculate(modifier, {
+      price: orderTotal,
       quantity: 1,
     });
 
-    const orderModifierTotal = math.abs(computed.amount);
+    const orderModifierTotal = math.abs(_computed.amount);
     const totalDistributed = items.reduce((acc, item) => {
-      const inheritedModifier = modifierService.createIndirectModifier(modifier, {
-        orderTotal: order.total,
-        itemTotal: item.total,
-        itemQuantity: item.quantity,
-      });
+      const inheritedModifier = modifierActions.createIndirectModifier(
+        modifier,
+        {
+          orderTotal,
+          itemTotal: item.total,
+          itemQuantity: item.quantity,
+        }
+      );
       itemsModifiers[item._id] = inheritedModifier;
-      return math.add(acc, math.mul(inheritedModifier.amount, item.quantity));
+      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);
+      const selectedItem = items.find(
+        item => math.sub(item.total, difference) > 0
+      );
 
-      const inheritedModifier = itemsModifiers[selectedItem._id];
-      itemsModifiers[selectedItem._id] = {
-        ...inheritedModifier,
-        amount: math.add(inheritedModifier.amount, math.div(difference, selectedItem.quantity)),
-      };
+      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

@@ -1,7 +1,9 @@
-module.exports = ({ utils, modifierService }) => {
+/* eslint-disable no-restricted-syntax */
+module.exports = ({ _, utils, modifierActions }) => {
   const { math } = utils;
   //
-  const calculateOne = (item) => {
+  const calculateOne = inputItem => {
+    const item = _.cloneDeep(inputItem);
     if (!item) return item;
 
     const subTotals = {
@@ -18,18 +20,37 @@ module.exports = ({ utils, modifierService }) => {
     subTotals._simple = math.mul(price, quantity);
 
     const modifiers = [];
+    const { modifiers: itemModifiers = [] } = item;
+    const amountOverride = itemModifiers.find(each =>
+      modifierActions.isAmountOverride(each)
+    );
 
-    if (Array.isArray(item.modifiers) && item.modifiers.length) {
+    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 = modifierService.sort(item.modifiers);
+      const sortedModifiers = modifierActions.sort(modifiersToCompute);
       let computedPrice = price;
       let prvPrice = 0;
       let prvSort;
 
-      for (const [idx, modifier] of sortedModifiers.entries()) {
-        const included = modifierService.isIncluded(modifier);
-        const direct = modifierService.isDirect(modifier);
-        const sort = modifierService.getProperty(modifier, 'sort');
+      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);
@@ -37,15 +58,19 @@ module.exports = ({ utils, modifierService }) => {
           prvSort = null;
         }
 
-        const _modifier = modifierService.calculate(modifier, {
+        const _modifier = modifierActions.calculate(modifier, {
           price: computedPrice,
           quantity,
+          skip: !!amountOverride,
         });
-        // console.log('computedPrice => ', computedPrice);
 
         modifiers.push(_modifier);
-        const { category, computed } = _modifier;
-        const computedAmount = math.mul(computed.amount, quantity);
+        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);
@@ -53,10 +78,7 @@ module.exports = ({ utils, modifierService }) => {
           prvSort = sort;
         } else {
           subTotals._xincluded = math.add(subTotals._xincluded, computedAmount);
-          subTotals[category] = math.add(
-            subTotals[category] || 0,
-            computedAmount
-          );
+          subTotals[type] = math.add(subTotals[type] || 0, computedAmount);
         }
         if (direct)
           subTotals._direct = math.add(subTotals._direct, computedAmount);
@@ -70,16 +92,16 @@ module.exports = ({ utils, modifierService }) => {
 
     return {
       ...item,
-      modifiers,
+      modifiers: [...modifiersToNotCompute, ...modifiers],
       subTotals,
       total,
     };
   };
 
   //
-  const calculateMany = (items = []) => items.map((item) => calculateOne(item));
+  const calculateMany = (items = []) => items.map(item => calculateOne(item));
 
-  return function calcultae(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(),
+    };
+  };
+};

package/lib/item/filterByDirectModifiers.js

@@ -1,14 +1,13 @@
 /**
  * Remove order modifiers from items
  */
-module.exports = ({ modifierService }) => {
+module.exports = ({ modifierActions }) =>
   //
-  return function filterByDirectModifiers(items = []) {
-    return items.map((item) => ({
+  function filterByDirectModifiers(items = []) {
+    return items.map(item => ({
       ...item,
-      modifiers: (item.modifiers || []).filter((modifier) =>
-        modifierService.isDirect(modifier)
+      modifiers: (item.modifiers || []).filter(modifier =>
+        modifierActions.isDirect(modifier)
       ),
     }));
   };
-};

package/lib/item/findOriginalItem.js

@@ -0,0 +1,8 @@
+module.exports = () =>
+  function findOriginalItem({ item, cache = {} }) {
+    const original =
+      Array.isArray(cache.items) &&
+      cache.items.find(each => each._id === item.itemId);
+
+    return original || item;
+  };

package/lib/item/getBalanceToPay.js

@@ -0,0 +1,12 @@
+module.exports = ({ utils }) =>
+  function getBalanceToPay({ orderItems = [] }) {
+    const total = orderItems.reduce(
+      (t, item) => utils.math.add(t, item && item.total),
+      0
+    );
+    const totalPaid = orderItems.reduce(
+      (t, item) => utils.math.add(t, item && item.totalPaid),
+      0
+    );
+    return utils.math.sub(total, totalPaid);
+  };

package/lib/item/getDepartmentModifiers.js

@@ -0,0 +1,5 @@
+module.exports = ({ modifierActions }) =>
+  function getDepartmentModifiers(item) {
+    if (!item || !Array.isArray(item.modifiers)) return [];
+    return modifierActions.getDepartmentModifiers(item.modifiers);
+  };

package/lib/item/getDiscountModifiers.js

@@ -0,0 +1,7 @@
+module.exports = ({ modifierActions }) =>
+  function getDiscountModifiers(item) {
+    if (!item || !Array.isArray(item.modifiers)) return [];
+    return item.modifiers.filter(
+      each => modifierActions.isDiscount(each) && modifierActions.isDirect(each)
+    );
+  };