@darkpos/pricing 1.0.5 → 1.0.8

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

package/lib/item/removeModifier.js

@@ -0,0 +1,84 @@
+module.exports = ({ modifierActions, _, actions }) => {
+  const hasRelatedItems = (modifiers = []) =>
+    !!modifiers.find(each => modifierActions.isGroupOfItems(each));
+
+  const isValid = (itemModifiers, modifier) => {
+    if (!modifierActions.findById(itemModifiers, modifier.modifierId))
+      return false;
+
+    if (
+      modifierActions.isRequired(modifier) &&
+      !modifierActions.isGroupOfValues(modifier) &&
+      !modifierActions.isRequiredAndOverride(modifier)
+    )
+      return false;
+
+    if (
+      !modifierActions.isGroupOfItems(modifier) &&
+      hasRelatedItems(itemModifiers)
+    )
+      return false;
+
+    return true;
+  };
+
+  return function removeModifier({
+    item,
+    modifier,
+    customer,
+    cache = {
+      items: [],
+    },
+  }) {
+    const nextItem = _.cloneDeep(item);
+    const itemModifiers = item.modifiers || [];
+    let modifiersToApply = [];
+
+    if (!isValid(itemModifiers, modifier)) return item;
+
+    // Check for multiple and add them to menuModifiers
+    if (modifierActions.hasAddModifiers(modifier)) {
+      const relatedModifiers = modifierActions.getRelatedModifiers(modifier);
+      // Removing only those children who are selected
+      const currentModifiersIds = itemModifiers.map(each => each.modifierId);
+      modifiersToApply = relatedModifiers.filter(each =>
+        currentModifiersIds.includes(each._id)
+      );
+    }
+
+    modifiersToApply.push(modifier);
+    // Remove
+    const nextModifiers = item.modifiers.filter(
+      each =>
+        !modifiersToApply.find(
+          mod =>
+            each.modifierId === mod._id ||
+            each._id === mod._id ||
+            each.modifierId === mod.modifierId
+        )
+    );
+
+    const hasOverride = modifiersToApply.find(each =>
+      modifierActions.isOverride(each)
+    );
+
+    if (hasOverride) {
+      const originalItem =
+        cache.items.find(_item => _item._id === item.itemId) || item;
+
+      if (modifierActions.isQuantityOverride(modifier)) nextItem.quantity = 1;
+
+      if (modifierActions.isPriceOverride(modifier))
+        nextItem.price = actions.getItemPrice({
+          item: originalItem,
+          cache,
+          customer,
+        });
+    }
+
+    return {
+      ...nextItem,
+      modifiers: nextModifiers,
+    };
+  };
+};

package/lib/item/removeModifierById.js

@@ -0,0 +1,8 @@
+module.exports = () =>
+  function removeModifierById({ item, modifierId }) {
+    if (!item || !modifierId) return item;
+    return {
+      ...item,
+      modifiers: item.modifiers.filter(modifier => modifier._id !== modifierId),
+    };
+  };

package/lib/item/removeModifiers.js

@@ -0,0 +1,14 @@
+module.exports = ({ actions }) =>
+  function removeModifiers({ item, modifiers, cache, customer }) {
+    const newItem = modifiers.reduce(
+      (nextItem, modifier) =>
+        actions.removeModifier({
+          item: nextItem,
+          modifier,
+          cache,
+          customer,
+        }),
+      item
+    );
+    return newItem;
+  };

package/lib/modifier/addFile.js

@@ -0,0 +1,19 @@
+module.exports = ({ actions }) =>
+  function addFile({ modifier, file, add = true }) {
+    if (!modifier || !file || !actions.isGroupOfValues(modifier)) return null;
+    let files = [...(modifier.properties.group.files || [])];
+
+    if (add) files.push(file);
+    else files = files.filter(each => each._id !== file._id);
+
+    return {
+      ...modifier,
+      properties: {
+        ...modifier.properties,
+        group: {
+          ...modifier.properties.group,
+          files,
+        },
+      },
+    };
+  };

package/lib/modifier/addImage.js

@@ -0,0 +1,18 @@
+module.exports = ({ actions }) =>
+  function addImage({ modifier, image, add = true }) {
+    if (!modifier || !image || !actions.isGroupOfValues(modifier)) return null;
+    let images = [...(modifier.properties.group.images || [])];
+    if (add) images.push(image);
+    else images = images.filter(each => each !== image);
+
+    return {
+      ...modifier,
+      properties: {
+        ...modifier.properties,
+        group: {
+          ...modifier.properties.group,
+          images,
+        },
+      },
+    };
+  };

package/lib/modifier/calculate.js

@@ -0,0 +1,43 @@
+/**
+ * Get calculated modifier
+ */
+module.exports = ({ _, constants, utils, localization, actions }) => {
+  const { math } = utils;
+  const { Modifier } = constants;
+
+  return function calculate(
+    modifier = {},
+    options = { price: 0, skip: false }
+  ) {
+    const { name, compute } = modifier;
+    const { type, action, amount = 0 } = compute || {};
+    const _computed = {
+      amount: 0,
+      description: '',
+    };
+    const maxAmount = actions.getProperty(modifier, 'maxAmount');
+    if (!options.skip) {
+      const multiplier = action === Modifier.Compute.Actions.SUBTRACT ? -1 : 1;
+
+      if (type === Modifier.Compute.Types.FIXED)
+        _computed.amount = math.mul(multiplier, amount);
+
+      if (type === Modifier.Compute.Types.PERCENTAGE)
+        _computed.amount = math.div(
+          math.mul(multiplier, options.price, amount),
+          100
+        );
+
+      if (!type || action === Modifier.Compute.Actions.OVERRIDE)
+        _computed.amount = amount;
+
+      if (maxAmount && math.gt(math.abs(_computed.amount), maxAmount))
+        _computed.amount = maxAmount;
+    }
+
+    const localAmount = localization.formatAmount(_computed.amount);
+    _computed.description = `${name} (${localAmount})`;
+
+    return { ..._.cloneDeep(modifier), _computed };
+  };
+};

package/lib/modifier/contains.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function contains(modifiers = [], modifier = null) {
+    if (!modifiers || !modifier) return false;
+    return !!modifiers.find(each => each.modifierId === modifier._id);
+  };

package/lib/modifier/convertMenuModifiers.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function convertMenuModifiers(menuModifiers) {
+    if (!Array.isArray(menuModifiers)) return [];
+    return menuModifiers.map(each => each.modifier || each);
+  };

package/lib/modifier/create.js

@@ -0,0 +1,44 @@
+module.exports = ({ utils }) => {
+  const { helpers } = utils;
+
+  const defaults = {
+    name: '',
+    sku: '',
+    description: '',
+    group: '',
+    type: '',
+    attributes: [],
+    color: '',
+    backgroundColor: '',
+    icon: '',
+    url: '',
+    code: '',
+    tags: [],
+    order: 0,
+    included: false,
+    direct: true,
+    hidden: false,
+    required: false,
+    print: true,
+    delModifiers: [],
+    addModifiers: [],
+    conditions: null,
+    compute: null,
+    properties: {},
+    get _id() {
+      return helpers.getObjectID();
+    },
+    modifierId: null,
+    __typename: 'Modifier',
+  };
+
+  return function create(params) {
+    const { _id, modifierId, ...modifier } = params;
+    const parentId = modifierId || _id;
+    return {
+      ...defaults,
+      ...modifier,
+      modifierId: parentId,
+    };
+  };
+};

package/lib/modifier/createAmountOverrideModifier.js

@@ -0,0 +1,20 @@
+module.exports = ({ constants, actions, utils }) => {
+  const { Modifier } = constants;
+  const { helpers } = utils;
+
+  return function createAmountOverrideModifier(params) {
+    return actions.create({
+      compute: {
+        amount: params.amount,
+        action: Modifier.Compute.Actions.OVERRIDE,
+      },
+      properties: {
+        override: { field: 'amount' },
+      },
+      attributes: [Modifier.Attributes.OVERRIDE],
+      name: `Modifier Amount ${Modifier.Compute.Actions.OVERRIDE}`,
+      included: true,
+      _id: helpers.getObjectID(),
+    });
+  };
+};