@darkpos/pricing 1.0.5 → 1.0.8

package/lib/modifier/createCreditModifier.js

@@ -0,0 +1,32 @@
+module.exports = ({ _, actions, utils }) => {
+  const { helpers } = utils;
+  //
+  return function createCreditModifier(modifier = {}) {
+    const { customerStoredCredit, ...rest } = _.cloneDeep(modifier);
+    if (!customerStoredCredit) return null;
+    let creditModifier;
+    if (!_.isEmpty(rest)) {
+      creditModifier = rest;
+    }
+    // create one
+    else {
+      creditModifier = actions.create({
+        _id: helpers.getObjectID(),
+        type: 'credit',
+        name: 'Customer stored credit',
+        direct: true,
+      });
+    }
+
+    creditModifier.compute = {
+      amount: 100,
+      type: 'percentage',
+      action: 'subtract',
+    };
+    creditModifier.properties = {
+      maxAmount: customerStoredCredit,
+      sort: 999,
+    };
+    return creditModifier;
+  };
+};

package/lib/modifier/createDiscountModifier.js

@@ -0,0 +1,25 @@
+module.exports = ({ constants, actions, localization, utils }) => {
+  const { helpers } = utils;
+  const { Modifier } = constants;
+
+  return function createDiscountModifier(params) {
+    const { amount, type } = params;
+    const { formatAmount } = localization;
+
+    const name =
+      type === Modifier.Compute.Types.PERCENTAGE
+        ? `${amount}%`
+        : `${formatAmount(amount)}`;
+
+    return actions.create({
+      compute: {
+        action: Modifier.Compute.Actions.SUBTRACT,
+        amount,
+        type,
+      },
+      type: Modifier.Types.DISCOUNT,
+      name: `${name} ${Modifier.Types.DISCOUNT}`,
+      _id: helpers.getObjectID(),
+    });
+  };
+};

package/lib/modifier/createGroupValuesModifier.js

@@ -0,0 +1,29 @@
+module.exports = ({ actions }) =>
+  function createGroupValuesModifier({ modifier, value, add = false }) {
+    if (!modifier || !value || !actions.isGroupOfValues(modifier)) return null;
+
+    const multiSelect = !actions.isSingleValue(modifier);
+    let selectedValues = [];
+    const modifierValues = [...modifier.properties.group.values, value];
+
+    if (!add) {
+      selectedValues = [...(modifier.properties.group.selectedValues || [])];
+      const remove = selectedValues.includes(value);
+      if (remove)
+        selectedValues = selectedValues.filter(each => each !== value);
+      else if (multiSelect) selectedValues.push(value);
+      else selectedValues = [value];
+    }
+
+    return {
+      ...modifier,
+      properties: {
+        ...modifier.properties,
+        group: {
+          ...modifier.properties.group,
+          selectedValues,
+          values: add ? [...new Set(modifierValues)] : [],
+        },
+      },
+    };
+  };

package/lib/modifier/createIndirectModifier.js

@@ -0,0 +1,42 @@
+/*
+ * create a distrubuted Modifier based on Order and Item
+ */
+module.exports = ({ _, utils, constants, actions }) => {
+  const { math } = utils;
+  const { Modifier } = constants;
+
+  return function createIndirectModifier(
+    modifier,
+    options = { orderTotal: 0, itemTotal: 0, itemQuantity: 1 }
+  ) {
+    const { compute = {} } = modifier;
+    const { type, amount = 0 } = compute;
+    let modifierAmount = amount;
+
+    if (type === Modifier.Compute.Types.PERCENTAGE)
+      modifierAmount = math.div(math.mul(options.orderTotal, amount), 100);
+
+    let amountToApply = 0;
+
+    if (!math.isZero(options.orderTotal))
+      amountToApply = math.div(
+        math.mul(modifierAmount, options.itemTotal),
+        options.orderTotal,
+        options.itemQuantity
+      );
+
+    const modifierToAdd = actions.create({
+      ..._.cloneDeep(modifier),
+      direct: false,
+      compute: {
+        type: Modifier.Compute.Types.FIXED,
+        amount: amountToApply,
+        action: compute.action || Modifier.Compute.Actions.SUBTRACT,
+      },
+    });
+    if (actions.getProperty(modifierToAdd, 'maxAmount') !== null)
+      delete modifierToAdd.properties.maxAmount;
+
+    return modifierToAdd;
+  };
+};

package/lib/modifier/createSubscriptionModifier.js

@@ -0,0 +1,19 @@
+module.exports = ({ constants, actions, utils }) => {
+  const { Modifier } = constants;
+  const { helpers } = utils;
+
+  return function createSubscriptionModifier(params = {}) {
+    return actions.create({
+      compute: {
+        action: Modifier.Compute.Actions.SUBTRACT,
+        type: Modifier.Compute.Types.FIXED,
+        amount: params.amount,
+      },
+      attributes: [Modifier.Attributes.SUBSCRIPTION],
+      name: Modifier.Attributes.SUBSCRIPTION,
+      type: Modifier.Types.DISCOUNT,
+      _id: helpers.getObjectID(),
+      ...params,
+    });
+  };
+};

package/lib/modifier/displayAsCard.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function displayAsCard(modifier) {
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.group &&
+      modifier.properties.group.displayType === 'card'
+    );
+  };

package/lib/modifier/displayAsChips.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function displayAsChips(modifier) {
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.group &&
+      modifier.properties.group.displayType === 'chips'
+    );
+  };

package/lib/modifier/displayAsList.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function displayAsList(modifier) {
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.group &&
+      modifier.properties.group.displayType === 'list'
+    );
+  };

package/lib/modifier/duplicate.js

@@ -0,0 +1,12 @@
+module.exports = ({ utils }) => {
+  const { helpers } = utils;
+  return function duplicate(modifier) {
+    if (!modifier) return null;
+
+    return {
+      ...modifier,
+      modifierId: modifier.modifierId || modifier._id,
+      _id: helpers.getObjectID(),
+    };
+  };
+};

package/lib/modifier/enableAutoPopup.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function enableAutoPopup(modifier) {
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.group &&
+      modifier.properties.group.enableAutoPopup
+    );
+  };

package/lib/modifier/filterByRequiredModifiers.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function filterByRequiredModifiers(modifiers) {
+    return modifiers.filter(each => each.required);
+  };

package/lib/modifier/findById.js

@@ -0,0 +1,7 @@
+module.exports = () =>
+  function findById(modifiers, id) {
+    if (!Array.isArray(modifiers)) return null;
+    return modifiers
+      .filter(Boolean)
+      .find(each => each._id === id || each.modifierId === id);
+  };

package/lib/modifier/findByPaymentMethod.js

@@ -0,0 +1,10 @@
+module.exports = ({ actions }) =>
+  function findByPaymentMethod({ modifiers, paymentMethod = '' }) {
+    if (!Array.isArray(modifiers) || !paymentMethod) return null;
+
+    return modifiers.find(
+      each =>
+        actions.isPaymentMethods(each) &&
+        each.conditions.paymentMethods.includes(paymentMethod)
+    );
+  };

package/lib/modifier/findByPaymentType.js

@@ -0,0 +1,10 @@
+module.exports = ({ actions }) =>
+  function findByPaymentType({ modifiers, paymentType = '' }) {
+    if (!Array.isArray(modifiers) || !paymentType) return null;
+
+    return modifiers.find(
+      each =>
+        actions.isPaymentTypes(each) &&
+        each.conditions.paymentTypes.includes(paymentType)
+    );
+  };

package/lib/modifier/getAvailablePromotions.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getAvailablePromotions(modifiers) {
+    if (!Array.isArray(modifiers)) return [];
+    return modifiers.filter(each => actions.isAvailablePromotion(each));
+  };

package/lib/modifier/getAvailablePromotionsOrSubscriptions.js

@@ -0,0 +1,15 @@
+module.exports = ({ actions }) =>
+  /*
+   * This function will receive a list of promotion modifiers and filter them by the limits that we have for promotions
+   * Filters are:
+   *  modifier.properties.promotion.dateLimit.{from, to} which compares today with these two dates
+   *  modifier.properties.promotion.numberOfUsesLimit which will be checked with modifier.properties.promotion.numberOfUses
+   */
+  function getAvailablePromotionsOrSubscriptions(modifiers) {
+    if (!Array.isArray(modifiers)) return [];
+    return modifiers.filter(
+      each =>
+        actions.isAvailableSubscription(each) ||
+        actions.isAvailablePromotion(each)
+    );
+  };

package/lib/modifier/getAvailableSubscriptions.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getAvailableSubscriptions(modifiers) {
+    if (!Array.isArray(modifiers)) return [];
+    return modifiers.filter(each => actions.isAvailableSubscription(each));
+  };

package/lib/modifier/getByAttribute.js

@@ -0,0 +1,6 @@
+module.exports = ({ actions }) =>
+  //
+  function getByAttribute(modifiers, attribute) {
+    if (!modifiers) return [];
+    return modifiers.filter(each => actions.hasAttribute(each, attribute));
+  };

package/lib/modifier/getCreditModifier.js

@@ -0,0 +1,6 @@
+module.exports = ({ actions }) =>
+  //
+  function getCreditModifier(modifiers) {
+    if (!modifiers) return null;
+    return modifiers.find(actions.isCredit);
+  };

package/lib/modifier/getDefaultModifiers.js

@@ -0,0 +1,4 @@
+module.exports = ({ actions }) =>
+  function getDefaultModifiers(modifiers) {
+    return (modifiers || []).filter(each => actions.isDefault(each));
+  };

package/lib/modifier/getDepartmentMaxItems.js

@@ -0,0 +1,10 @@
+module.exports = () =>
+  function getDepartmentMaxItems(modifier) {
+    return (
+      (modifier &&
+        modifier.properties &&
+        modifier.properties.department &&
+        modifier.properties.department.maxItems) ||
+      0
+    );
+  };

package/lib/modifier/getDepartmentModifiers.js

@@ -0,0 +1,11 @@
+module.exports = ({ actions, utils }) => {
+  const { math } = utils;
+  const getOrder = modifier => (modifier && modifier.order) || 0;
+
+  return function getDepartmentModifiers(modifiers) {
+    if (!modifiers || !Array.isArray(modifiers)) return [];
+    return modifiers
+      .filter(each => actions.isDepartment(each))
+      .sort((mod1, mod2) => math.sub(getOrder(mod1), getOrder(mod2)));
+  };
+};

package/lib/modifier/getDescription.js

@@ -0,0 +1,6 @@
+module.exports = () =>
+  function getDescription(modifier) {
+    return (
+      (modifier && modifier._computed && modifier._computed.description) || ''
+    );
+  };

package/lib/modifier/getDescriptions.js

@@ -0,0 +1,9 @@
+module.exports = ({ actions }) =>
+  function getDescriptions(modifiers) {
+    if (!Array.isArray(modifiers)) return '';
+
+    const descriptions = modifiers
+      .map(each => actions.getDescription(each))
+      .filter(Boolean);
+    return descriptions.join(', ');
+  };

package/lib/modifier/getDirectModifiers.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getDirectModifiers(modifiers) {
+    if (!Array.isArray(modifiers)) return [];
+    return modifiers.filter(each => actions.isDirect(each));
+  };

package/lib/modifier/getDiscountModifiers.js

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

package/lib/modifier/getEntityModifiers.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function getEntityModifiers(entity) {
+    if (!entity || !entity.modifiers || !entity.modifiers.length) return [];
+    return entity.modifiers.map(each => {
+      const modifierId = each.modifierId || each._id;
+      return {
+        ...each,
+        modifierId,
+      };
+    });
+  };

package/lib/modifier/getEntityPromotions.js

@@ -0,0 +1,11 @@
+module.exports = ({ actions }) =>
+  function getEntityPromotions({ modifiers, entity }) {
+    if (!entity) return [];
+    let entityModifiers = actions.getMatchTagsModifiers({
+      modifiers,
+      entity,
+    });
+    entityModifiers = actions.getUnhiddenModifiers(entityModifiers);
+    const promotions = actions.getAvailablePromotions(entityModifiers);
+    return promotions;
+  };

package/lib/modifier/getExtendedTags.js

@@ -0,0 +1,14 @@
+module.exports = ({ actions }) =>
+  function getExtendedTags(modifiers) {
+    if (!modifiers) return [];
+    const filteredModifiers = modifiers.filter(each =>
+      actions.isCustomerTagsExtend(each)
+    );
+    if (!filteredModifiers.length) return [];
+
+    const extendedTags = filteredModifiers.reduce(
+      (arr, each) => arr.concat(each.properties.department.customerTagsExtend),
+      []
+    );
+    return extendedTags;
+  };

package/lib/modifier/getFiles.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getFiles(modifier) {
+    if (!actions.isGroupOfValues(modifier)) return [];
+    return modifier.properties.group.files || [];
+  };

package/lib/modifier/getGroupModifiers.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function getGroupModifiers({ modifier, includeParent = true }) {
+    const { properties } = modifier;
+    if (!properties || !properties.group) return [];
+    const { modifiers = [] } = properties.group;
+    const groupModifiers = [...modifiers];
+    if (includeParent) groupModifiers.push(modifier);
+    return groupModifiers.filter(Boolean);
+  };

package/lib/modifier/getGroupOfItemsModifiers.js

@@ -0,0 +1,4 @@
+module.exports = ({ actions }) =>
+  function getGroupOfItemsModifiers(modifiers = []) {
+    return modifiers.filter(each => actions.isGroupOfItems(each));
+  };

package/lib/modifier/getGroupRelatedModifiers.js

@@ -0,0 +1,26 @@
+module.exports = ({ actions }) => {
+  const find = (modifiers = [], modifierId = '') =>
+    modifiers.find(each => each._id === modifierId);
+  // This method returns all modifiers which are referenced by a modifier
+  return function getGroupRelatedModifiers({ cache, modifier }) {
+    if (!modifier) return [];
+    const checkCache = Array.isArray(cache) && cache.length;
+    const modifiers = actions.getGroupModifiers({
+      modifier,
+      includeParent: false,
+    });
+
+    const groupModifiers = modifiers.reduce((arr, each) => {
+      if (!each || !each._id) return arr;
+      if (checkCache) {
+        const org = find(cache, each.modifierId || each._id);
+        if (org) arr.push(org);
+      }
+      return arr;
+    }, []);
+
+    if (actions.includesInGroup(modifier)) groupModifiers.unshift(modifier);
+
+    return groupModifiers;
+  };
+};

package/lib/modifier/getImages.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getImages(modifier) {
+    if (!actions.isGroupOfValues(modifier)) return [];
+    return modifier.properties.group.images || [];
+  };

package/lib/modifier/getInheritedModifiers.js

@@ -0,0 +1,30 @@
+module.exports = ({ actions }) => {
+  const isRelated = modifier => actions.isGroupOfItems(modifier);
+
+  return function getInheritedModifiers({ parentItem, childItem }) {
+    if (!parentItem || !childItem) return [];
+
+    const { addModifiers: parentModifiers } = parentItem;
+    const { addModifiers: childModifiers = [], _id } = childItem;
+    const modifiers = [...childModifiers];
+
+    const relatedItemModifier = parentModifiers.find(each => isRelated(each));
+    if (!relatedItemModifier) return modifiers;
+
+    const { properties = {} } = relatedItemModifier;
+    const items = (properties.group && properties.group.items) || [];
+
+    const relatedItem = items.find(each => each._id === _id);
+    if (!relatedItem) return [];
+
+    if (properties.inheritModifiers && parentModifiers.length) {
+      const inheritedModifiers = parentModifiers
+        .filter(each => !isRelated(each))
+        .map(each => actions.duplicate(each));
+
+      if (inheritedModifiers.length) modifiers.push(...inheritedModifiers);
+    }
+
+    return actions.purifyModifiers(modifiers);
+  };
+};

package/lib/modifier/getItemModifiers.js

@@ -0,0 +1,39 @@
+module.exports = ({ actions, utils }) => {
+  const { helpers } = utils;
+  return function getItemModifiers({ modifiers, customer, cache }) {
+    const matchedModifiers = actions.getMatchTagsModifiers({
+      modifiers,
+      entity: customer,
+    });
+
+    const enabledModifiers = matchedModifiers.filter(
+      each =>
+        (actions.isDefault(each) || actions.isRequired(each)) &&
+        !(actions.isGroupOfValues(each) || actions.isGroupOfModifiers(each))
+    );
+
+    const relatedModifiers = enabledModifiers
+      .map(each =>
+        actions.getRelatedModifiers({
+          modifier: each,
+          modifiers,
+        })
+      )
+      .reduce((acc, val) => acc.concat(val), []);
+
+    const starchModifier = actions.getStarchModifier({
+      cache,
+      modifiers: enabledModifiers,
+      starch: customer && customer.properties && customer.properties.starch,
+    });
+
+    const itemModifiers = [...enabledModifiers, ...relatedModifiers];
+    if (starchModifier) itemModifiers.push(starchModifier);
+
+    return itemModifiers.map(each => ({
+      ...each,
+      modifierId: each.modifierId || each._id,
+      _id: helpers.getObjectID(),
+    }));
+  };
+};

package/lib/modifier/getLaundryModifiers.js

@@ -0,0 +1,9 @@
+module.exports = ({ actions }) =>
+  function getLaundryModifiers(modifiers = []) {
+    return modifiers.filter(
+      each =>
+        actions.isDepartment(each) &&
+        each.properties.department.code &&
+        each.properties.department.code.toLowerCase() === 'l'
+    );
+  };

package/lib/modifier/getMatchTagsModifiers.js

@@ -0,0 +1,9 @@
+module.exports = ({ actions }) =>
+  function getMatchTagsModifiers({ modifiers, entity }) {
+    if (!Array.isArray(modifiers)) return [];
+
+    return modifiers.filter(each => {
+      const modifier = each.modifier || each;
+      return modifier && actions.hasMatchTags(modifier, entity);
+    });
+  };

package/lib/modifier/getModifierIndex.js

@@ -0,0 +1,14 @@
+module.exports = () =>
+  /*
+   * will check the entity to find the input modifier
+   * if it finds the modifier will return the index of modifier
+   * otherwise will return -1
+   * */
+  function getModifierIndex({ entity, modifier }) {
+    if (!entity || !modifier) return -1;
+    const { modifiers = [] } = entity;
+    const { _id } = modifier;
+    return modifiers.findIndex(
+      each => each.modifierId === _id || each._id === _id
+    );
+  };

package/lib/modifier/getPreferences.js

@@ -0,0 +1,24 @@
+module.exports = ({ actions, _ }) =>
+  /**
+   * This function is for fetching preference Modifiers
+   */
+  function getPreferences(modifiers) {
+    if (!Array.isArray(modifiers) || !modifiers.length) return [];
+
+    const preferences = modifiers.filter(modifier =>
+      actions.isPreferences(modifier)
+    );
+    if (!Array.isArray(preferences) || !preferences.length) return [];
+
+    const groups = preferences.map(modifier => modifier.group).filter(Boolean);
+    const sortedGroups = _.sortBy([...new Set(groups)]);
+
+    const categories = sortedGroups.map(name => ({
+      name,
+      modifiers: _.sortBy(
+        preferences.filter(each => each.group === name),
+        ['order']
+      ),
+    }));
+    return categories;
+  };

package/lib/modifier/getPromotionModifiers.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getPromotionModifiers(modifiers) {
+    if (!Array.isArray(modifiers)) return [];
+    return modifiers.filter(each => actions.isPromotion(each));
+  };

package/lib/modifier/getPromptMessage.js

@@ -0,0 +1,6 @@
+module.exports = ({ actions }) =>
+  function getPromptMessage(modifier) {
+    return actions.hasDisplayPrompt(modifier)
+      ? modifier.properties.group.promptMessage
+      : null;
+  };

package/lib/modifier/getProperty.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function getProperty(modifier, key) {
+    if (
+      modifier &&
+      modifier.properties &&
+      // eslint-disable-next-line no-prototype-builtins
+      modifier.properties.hasOwnProperty(key)
+    )
+      return modifier.properties[key];
+    return null;
+  };

package/lib/modifier/getRecommendedModifiers.js

@@ -0,0 +1,7 @@
+module.exports = () =>
+  function getRecommendedModifiers(modifiers) {
+    return modifiers.filter(each => {
+      const modifier = each.modifier || each;
+      return modifier.recommended;
+    });
+  };

package/lib/modifier/getRelatedModifiers.js

@@ -0,0 +1,10 @@
+module.exports = ({ actions }) =>
+  function getRelatedModifiers({ modifier, modifiers }) {
+    if (!modifier || !modifier.addModifiers || !modifiers) return [];
+    // get related modifiers
+    const relatedModifiers = modifier.addModifiers
+      .map(each => actions.findById(modifiers, each._id))
+      .filter(Boolean);
+
+    return relatedModifiers;
+  };

package/lib/modifier/getRequiredModifiers.js

@@ -0,0 +1,4 @@
+module.exports = ({ actions }) =>
+  function getRequiredModifiers(modifiers) {
+    return modifiers.filter(each => actions.isRequired(each));
+  };

package/lib/modifier/getSelectedValues.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function getSelectedValues(modifier) {
+    if (!actions.isGroupOfValues(modifier)) return null;
+    if (Array.isArray(modifier.properties.group.selectedValues))
+      return modifier.properties.group.selectedValues.join(', ');
+    return null;
+  };