@darkpos/pricing 1.0.5 → 1.0.6

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)
+    );
+  };

package/lib/item/getItemModifiers.js

@@ -0,0 +1,16 @@
+module.exports = ({ modifierActions }) =>
+  function getItemModifiers(item, orderModifiers) {
+    const existsInOrderModifier = modifier =>
+      orderModifiers &&
+      orderModifiers.find(each => each.modifierId === modifier.modifierId);
+
+    let modifiers = [];
+    if (!item || !Array.isArray(item.modifiers)) return modifiers;
+
+    modifiers.push(...item.modifiers);
+
+    if (Array.isArray(orderModifiers) && orderModifiers.length)
+      modifiers = modifiers.filter(each => !existsInOrderModifier(each));
+
+    return modifiers.filter(modifierActions.isDirect);
+  };

package/lib/item/getItemModifiersDescription.js

@@ -0,0 +1,22 @@
+module.exports = ({ modifierActions }) =>
+  function getItemModifiersDescription(item) {
+    if (!item || !Array.isArray(item.modifiers)) return [];
+    const description = item.modifiers
+      .filter(
+        each =>
+          !modifierActions.isHidden(each) &&
+          !modifierActions.isAmountOverride(each) &&
+          modifierActions.isDirect(each)
+      )
+      .map(modifier => {
+        const { name } = modifier;
+        let label = name;
+        if (modifierActions.isGroupOfValues(modifier))
+          label = modifierActions.getSelectedValues(modifier) || label;
+
+        return label;
+      })
+      .join(', ');
+
+    return description;
+  };

package/lib/item/getItemPrice.js

@@ -0,0 +1,57 @@
+module.exports = ({ actions, modifierActions, utils }) => {
+  const { math } = utils;
+
+  const getCustomerTags = (customer = {}) =>
+    ((customer && customer.tags) || []).filter(Boolean);
+
+  return function getItemPrice({ item, cache, customer }) {
+    const modifiers = item.modifiers || [];
+    let { priceLevels } = item;
+
+    // get cache Item
+    if (cache && cache.items) {
+      const orgItem = actions.findOriginalItem({
+        item,
+        cache,
+      });
+      ({ priceLevels } = orgItem);
+    }
+
+    if (!priceLevels) return 0;
+
+    const extendedTags = modifierActions.getExtendedTags(modifiers);
+    const customerTags = getCustomerTags(customer).concat(extendedTags);
+
+    const matchedPriceLevels = priceLevels.filter(
+      priceLevel =>
+        priceLevel.tags &&
+        priceLevel.tags.every(tag => customerTags.includes(tag))
+    );
+    if (!matchedPriceLevels.length) return 0;
+    const maxPriceLevel = matchedPriceLevels.reduce(
+      (prevPriceLevel, priceLevel) => {
+        const curLength = priceLevel.tags.length;
+        const preLength = prevPriceLevel.tags.length;
+
+        if (curLength > preLength) return priceLevel;
+        if (preLength === curLength && priceLevel.value < prevPriceLevel.value)
+          return priceLevel;
+
+        return prevPriceLevel;
+      }
+    );
+
+    const { value } = maxPriceLevel;
+
+    const overridPriceModifier = modifiers.find(each =>
+      modifierActions.isPriceOverride(each)
+    );
+    if (overridPriceModifier && overridPriceModifier.compute) {
+      if (modifierActions.isMultiplier(overridPriceModifier))
+        return math.mul(value, overridPriceModifier.compute.amount);
+      return overridPriceModifier.compute.amount;
+    }
+
+    return value;
+  };
+};

package/lib/item/getItemsTotalPaid.js

@@ -0,0 +1,9 @@
+module.exports = ({ utils }) =>
+  function getItemsTotalPaid({ orderItems = [] }) {
+    return (
+      orderItems.reduce(
+        (t, item) => utils.math.add(t, item && item.totalPaid),
+        0
+      ) || 0
+    );
+  };

package/lib/item/getItemsTotalPieces.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function getItemsTotalPieces(items) {
+    return items.reduce(
+      (total, item) => total + actions.getItemTotalPieces(item),
+      0
+    );
+  };

package/lib/item/getNotIncludedModifiers.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function getNotIncludedModifiers({ item, modifiers }) {
+    if (!item || !item.modifiers || !modifiers) return [];
+    return modifiers.filter(
+      each =>
+        !item.modifiers.find(
+          modifier =>
+            each._id === modifier.modifierId || each._id === modifier._id
+        )
+    );
+  };

package/lib/item/getParentItem.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function getParentItem(items, item) {
+    if (!Array.isArray(items) || !item) return null;
+    return items.find(each => each._id === item.properties.parentId);
+  };

package/lib/item/getPendingIndex.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function getPendingIndex(items) {
+    if (!items || !items.length) return -1;
+    return items.findIndex(each => each.isPending);
+  };

package/lib/item/getTotal.js

@@ -0,0 +1,8 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+  return function getTotal(item) {
+    if (!item || !item.subTotals) return 0;
+
+    return math.add(item.subTotals._simple, item.subTotals._direct);
+  };
+};

package/lib/item/getTotalPieces.js

@@ -0,0 +1,7 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+  return function getTotalPieces(item) {
+    if (!item) return 0;
+    return math.mul(item.quantity || 1, item.pieces || 1);
+  };
+};

package/lib/item/getTotals.js

@@ -0,0 +1,25 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+  return function getTotals(items) {
+    if (!Array.isArray(items)) return { total: 0, subTotals: {} };
+    return items.reduce(
+      (acc, item) => {
+        const subTotals = {};
+        const { subTotals: itemSubTotals = {} } = item;
+        const keys = Object.keys(itemSubTotals);
+        // eslint-disable-next-line no-restricted-syntax
+        for (const key of keys)
+          subTotals[key] = math.add(
+            acc.subTotals[key] || 0,
+            itemSubTotals[key]
+          );
+
+        return {
+          total: math.add(acc.total, item.total),
+          subTotals,
+        };
+      },
+      { total: 0, subTotals: {} }
+    );
+  };
+};

package/lib/item/hasCreateSubscription.js

@@ -0,0 +1,7 @@
+module.exports = ({ modifierActions }) =>
+  function hasCreateSubscription(items) {
+    return (
+      Array.isArray(items) &&
+      items.some(item => modifierActions.hasCreateSubscription(item.modifiers))
+    );
+  };

package/lib/item/hasModifier.js

@@ -0,0 +1,15 @@
+module.exports = () =>
+  function hasModifier({ item, modifier }) {
+    if (!item || !modifier || !item.modifiers) return false;
+
+    const itemModifier = item.modifiers.find(
+      each =>
+        (each.modifierId &&
+          (each.modifierId === modifier.modifierId ||
+            each.modifierId === modifier._id)) ||
+        (typeof each.modifier === 'object' &&
+          each.modifier._id === modifier.modifierId)
+    );
+
+    return !!itemModifier;
+  };

package/lib/item/hasModifierWithValue.js

@@ -0,0 +1,11 @@
+module.exports = ({ modifierActions }) =>
+  function hasModifierWithValue({ item, modifier, value }) {
+    if (!item || !modifier || !item.modifiers) return false;
+    const relatedModifier = item.modifiers.find(
+      itemModifier => modifier._id === itemModifier.modifierId
+    );
+    return modifierActions.isValueSelected({
+      modifier: relatedModifier,
+      value,
+    });
+  };

package/lib/item/hasModifiers.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function hasModifiers({ item, modifiers }) {
+    if (!item || !modifiers || !item.modifiers) return false;
+
+    return item.modifiers.some(
+      itemModifier =>
+        !!modifiers.find(each => each._id === itemModifier.modifierId)
+    );
+  };

package/lib/item/hasSubscription.js

@@ -0,0 +1,5 @@
+module.exports = ({ modifierActions }) =>
+  function hasSubscription(item) {
+    if (!item || !Array.isArray(item.modifiers)) return false;
+    return !!item.modifiers.find(each => modifierActions.isSubscription(each));
+  };

package/lib/item/index.js

@@ -1,12 +1,82 @@
-const makeFilterByDirectModifiers = require('./filterByDirectModifiers');
-const makeAddIndirectModifier = require('./addIndirectModifier');
-const makeCalculate = require('./calculate');
-
-module.exports = (deps = {}) => {
-  //
-  return Object.freeze({
-    calculate: makeCalculate(deps),
-    addIndirectModifier: makeAddIndirectModifier(deps),
-    filterByDirectModifiers: makeFilterByDirectModifiers(deps),
+const getItemsTotalPieces = require('./getItemsTotalPieces');
+const getTotalPieces = require('./getTotalPieces');
+const removeModifier = require('./removeModifier');
+const removeModifiers = require('./removeModifiers');
+const findOriginalItem = require('./findOriginalItem');
+const create = require('./create');
+const hasModifier = require('./hasModifier');
+const isSelected = require('./isSelected');
+const hasModifiers = require('./hasModifiers');
+const openRecommendationDialog = require('./openRecommendationDialog');
+const addIndirectModifier = require('./addIndirectModifier');
+const calculate = require('./calculate');
+const filterByDirectModifiers = require('./filterByDirectModifiers');
+const getItemPrice = require('./getItemPrice');
+const getDepartmentModifiers = require('./getDepartmentModifiers');
+const hasSubscription = require('./hasSubscription');
+const removeModifierById = require('./removeModifierById');
+const getDiscountModifiers = require('./getDiscountModifiers');
+const getTotal = require('./getTotal');
+const getPendingIndex = require('./getPendingIndex');
+const getTotals = require('./getTotals');
+const getNotIncludedModifiers = require('./getNotIncludedModifiers');
+const hasModifierWithValue = require('./hasModifierWithValue');
+const getBalanceToPay = require('./getBalanceToPay');
+const getItemsTotalPaid = require('./getItemsTotalPaid');
+const getItemModifiersDescription = require('./getItemModifiersDescription');
+const isRelatedItem = require('./isRelatedItem');
+const getParentItem = require('./getParentItem');
+const isParentIncluded = require('./isParentIncluded');
+const hasCreateSubscription = require('./hasCreateSubscription');
+const getItemModifiers = require('./getItemModifiers');
+
+const itemActions = (deps = {}) => {
+  const actions = {};
+
+  const innerDeps = {
+    ...deps,
+    actions,
+  };
+
+  const freezedActions = Object.freeze({
+    getItemsTotalPieces: getItemsTotalPieces(innerDeps),
+    getTotalPieces: getTotalPieces(innerDeps),
+    removeModifier: removeModifier(innerDeps),
+    removeModifiers: removeModifiers(innerDeps),
+    findOriginalItem: findOriginalItem(innerDeps),
+    create: create(innerDeps),
+    hasModifier: hasModifier(innerDeps),
+    isSelected: isSelected(innerDeps),
+    hasModifiers: hasModifiers(innerDeps),
+    openRecommendationDialog: openRecommendationDialog(innerDeps),
+    addIndirectModifier: addIndirectModifier(innerDeps),
+    calculate: calculate(innerDeps),
+    filterByDirectModifiers: filterByDirectModifiers(innerDeps),
+    getItemPrice: getItemPrice(innerDeps),
+    getDepartmentModifiers: getDepartmentModifiers(innerDeps),
+    hasSubscription: hasSubscription(innerDeps),
+    removeModifierById: removeModifierById(innerDeps),
+    getDiscountModifiers: getDiscountModifiers(innerDeps),
+    getTotal: getTotal(innerDeps),
+    getPendingIndex: getPendingIndex(innerDeps),
+    getTotals: getTotals(innerDeps),
+    getNotIncludedModifiers: getNotIncludedModifiers(innerDeps),
+    hasModifierWithValue: hasModifierWithValue(innerDeps),
+    getBalanceToPay: getBalanceToPay(innerDeps),
+    getItemsTotalPaid: getItemsTotalPaid(innerDeps),
+    getItemModifiersDescription: getItemModifiersDescription(innerDeps),
+    isRelatedItem: isRelatedItem(innerDeps),
+    getParentItem: getParentItem(innerDeps),
+    isParentIncluded: isParentIncluded(innerDeps),
+    hasCreateSubscription: hasCreateSubscription(innerDeps),
+    getItemModifiers: getItemModifiers(innerDeps),
   });
+
+  Object.keys(freezedActions).forEach(actionName => {
+    actions[actionName] = freezedActions[actionName];
+  });
+
+  return freezedActions;
 };
+
+module.exports = itemActions;

package/lib/item/isParentIncluded.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isParentIncluded(item) {
+    return item && item.properties && item.properties.includeParent;
+  };

package/lib/item/isRelatedItem.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isRelatedItem(item) {
+    return !!(item && item.properties && item.properties.relatedItem);
+  };

package/lib/item/isSelected.js

@@ -0,0 +1,13 @@
+module.exports = ({ modifierActions, actions }) =>
+  function isSelected({ item, modifier }) {
+    if (!item || !item.modifiers || !modifier) return false;
+    let hasModifier = actions.hasModifier({ item, modifier });
+
+    if (!hasModifier && modifierActions.isGroupOfModifiers(modifier))
+      hasModifier = actions.hasModifiers({
+        item,
+        modifiers: modifier.properties.group.modifiers,
+      });
+
+    return hasModifier;
+  };

package/lib/item/openRecommendationDialog.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function openRecommendationDialog(item) {
+    return !!(item && item.openRecommendationDialog);
+  };