@darkpos/pricing 1.0.3 → 1.0.6

package/lib/index.js

@@ -1,9 +1,36 @@
-const modifier = require('./modifier');
-const item = require('./item');
-const order = require('./order');
-
-module.exports = {
-  modifier,
-  item,
-  order,
-};
+const makeModifierService = require('@darkpos/modifier');
+const utils = require('@darkpos/utils');
+const _ = require('lodash');
+const moment = require('moment-timezone');
+/** services  */
+const makeItemActions = require('./item');
+const makeOrderActions = require('./order');
+
+module.exports = session => {
+  const { useLocalization } = utils;
+  const settings = _.get(session, 'store._settings', {});
+  const localization = useLocalization(settings.localization);
+
+  const deps = {
+    settings,
+    utils,
+    localization,
+    _,
+    moment,
+  };
+
+  //
+  const modifierActions = makeModifierService(session);
+  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(),
+    };
+  };
+};

package/lib/item/filterByDirectModifiers.js

@@ -0,0 +1,13 @@
+/**
+ * Remove order modifiers from items
+ */
+module.exports = ({ modifierActions }) =>
+  //
+  function filterByDirectModifiers(items = []) {
+    return items.map(item => ({
+      ...item,
+      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,6 +1,82 @@
-const { filterExports } = require('../utils');
-const actions = require('./actions');
+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');
 
-module.exports = {
-  actions: filterExports(actions),
+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);
+  };