@darkpos/pricing 1.0.6 → 1.0.7

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

package/lib/modifier/getService.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getService(modifier) {
+    if (!actions.isService(modifier)) return null;
+    return modifier.properties.override.service;
+  };

package/lib/modifier/getSplittedModifiers.js

@@ -0,0 +1,30 @@
+module.exports = ({ utils }) => {
+  const { math, helpers } = utils;
+  return function getSplittedModifiers(
+    modifiers,
+    totalOriginOrder,
+    totalSplitedOrder
+  ) {
+    return modifiers.map(each => {
+      const modifier = { ...each };
+      const { compute = {} } = modifier;
+      if (compute.type === 'fixed' && compute.amount) {
+        const amount = totalOriginOrder
+          ? math.div(
+              math.mul(compute.amount, totalSplitedOrder || 0),
+              totalOriginOrder
+            )
+          : 0;
+        return {
+          ...modifier,
+          _id: helpers.getObjectID(),
+          compute: {
+            ...compute,
+            amount,
+          },
+        };
+      }
+      return modifier;
+    });
+  };
+};

package/lib/modifier/getStarchModifier.js

@@ -0,0 +1,9 @@
+module.exports = ({ actions }) =>
+  function getStarchModifier({ modifiers, starch, cache = {} }) {
+    const laundryModifiers = actions.getLaundryModifiers(modifiers);
+
+    if (cache && cache.modifiers && laundryModifiers.length && starch)
+      return actions.findById(cache.modifiers, starch);
+
+    return null;
+  };

package/lib/modifier/getSubscriptionItem.js

@@ -0,0 +1,12 @@
+module.exports = () =>
+  function getSubscriptionItem(modifier) {
+    if (
+      modifier &&
+      modifier.properties &&
+      modifier.properties.subscription &&
+      modifier.properties.subscription.item
+    )
+      return modifier.properties.subscription.item;
+
+    return null;
+  };

package/lib/modifier/getSubscriptionModifiers.js

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

package/lib/modifier/getSuggestion.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function getSuggestion(modifier) {
+    const none = 'none';
+    if (!modifier) return none;
+    if (modifier.required) return 'required';
+    if (modifier.recommended) return 'recommended';
+    if (modifier.default) return 'default';
+    return none;
+  };

package/lib/modifier/getUnhiddenModifiers.js

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

package/lib/modifier/getUsingCount.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function getUsingCount(modifiers, modifier) {
+    if (!Array.isArray(modifiers) || !modifier) return false;
+    let count = 0;
+    modifiers.forEach(each => {
+      if (each.modifierId === modifier._id) {
+        count += 1;
+      }
+    });
+    return count;
+  };

package/lib/modifier/hasAddModifiers.js

@@ -0,0 +1,5 @@
+// TODO: change
+module.exports = () =>
+  function hasAddModifiers(modifier) {
+    return !!(modifier && (modifier.addModifiers || []).length);
+  };

package/lib/modifier/hasAllTag.js

@@ -0,0 +1,12 @@
+module.exports = () =>
+  /*
+   * Check if entity has the 'ALL' tag
+   * this helps us to check if the modifier with tags
+   * can have access to other entities without tags or not
+   * will return true if the entity has 'ALL' tag or false otherwise
+   * */
+  function hasAllTag(modifier) {
+    if (!modifier || !Array.isArray(modifier.tags)) return false;
+
+    return !!modifier.tags.find(tag => tag.toUpperCase() === 'ALL');
+  };

package/lib/modifier/hasAttribute.js

@@ -0,0 +1,8 @@
+module.exports = () =>
+  //
+  function hasAttribute(modifier, attribute) {
+    if (!modifier || !attribute || !Array.isArray(modifier.attributes))
+      return false;
+
+    return modifier.attributes.includes(attribute);
+  };

package/lib/modifier/hasAttributes.js

@@ -0,0 +1,19 @@
+module.exports = ({ actions }) =>
+  /*
+   * will find the attributes in modifier
+   * if it finds any of the attributes will return true
+   * otherwise will return false
+   * */
+  function hasAttributes(modifier, attributes) {
+    if (
+      !modifier ||
+      !Array.isArray(attributes) ||
+      !Array.isArray(modifier.attributes)
+    )
+      return false;
+
+    for (let i = 0; i < attributes.length; i += 1) {
+      if (actions.hasAttribute(modifier, attributes[i])) return true;
+    }
+    return false;
+  };

package/lib/modifier/hasCreateSubscription.js

@@ -0,0 +1,10 @@
+module.exports = ({ _ }) =>
+  function hasCreateSubscription(modifiers) {
+    return (
+      Array.isArray(modifiers) &&
+      modifiers.some(modifier => {
+        const subscription = _.get(modifier, 'properties.subscription');
+        return subscription && subscription.create;
+      })
+    );
+  };

package/lib/modifier/hasDisplayPrompt.js

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

package/lib/modifier/hasMatchTags.js

@@ -0,0 +1,27 @@
+module.exports = ({ actions }) =>
+  /* checks if the customer can be matched with the entity or not,
+   * This function will return true in these conditions:
+   *    Neither customer nor the entity has any tags
+   *    Customer has no tags and entity has the 'all' tag
+   *    customer has the 'all' tag and entity has no tags
+   *    customer and entity have at least one exact tag (case-sensitive)
+   * In any other case the function should return false
+   * */
+  function hasMatchTags(modifier, entity) {
+    const entityNoTags = actions.hasNoTags(entity);
+    const modifierNoTags = actions.hasNoTags(modifier);
+    if (
+      (modifierNoTags && entityNoTags) ||
+      (entityNoTags && actions.hasAllTag(modifier)) || // customer has no tags but modifier has the all tag
+      (modifierNoTags && actions.hasAllTag(entity)) // modifier has no tags but customer has the all tag
+    ) {
+      return true;
+    }
+
+    if (!entity || !entity.tags) return false;
+    if (!modifier || !modifier.tags) return false;
+
+    const sameTag = modifier.tags.find(tag => entity.tags.includes(tag));
+
+    return !!sameTag;
+  };

package/lib/modifier/hasModifier.js

@@ -0,0 +1,12 @@
+module.exports = () =>
+  /*
+   * will return true if the modifier is in entity and false if it is not
+   * */
+  function hasModifier({ entity, modifier }) {
+    if (!entity || !Array.isArray(entity.modifiers) || !modifier) return false;
+
+    const { _id } = modifier;
+    return !!entity.modifiers.find(
+      each => each.modifierId === _id || each._id === _id
+    );
+  };

package/lib/modifier/hasNoTags.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  /*
+   * Checks if the entity has any tags or not
+   * will return true if the entity has not any tag
+   * will return false otherwise
+   * */
+  function hasNoTags(modifier) {
+    return !modifier || !Array.isArray(modifier.tags) || !modifier.tags.length;
+  };

package/lib/modifier/hasRelatedItems.js

@@ -0,0 +1,8 @@
+module.exports = ({ actions }) =>
+  function hasRelatedItems(modifier) {
+    return !!(
+      actions.isGroupOfItems(modifier) &&
+      (modifier.properties.group.displayType === 'none' ||
+        !modifier.properties.group.displayType)
+    );
+  };

package/lib/modifier/includePiecesInQuantity.js

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

package/lib/modifier/includesInGroup.js

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