@darkpos/pricing 1.0.5 → 1.0.8

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

package/lib/modifier/index.js

@@ -0,0 +1,242 @@
+//
+const addFile = require('./addFile');
+const addImage = require('./addImage');
+const calculate = require('./calculate');
+const contains = require('./contains');
+const convertMenuModifiers = require('./convertMenuModifiers');
+const create = require('./create');
+const createAmountOverrideModifier = require('./createAmountOverrideModifier');
+const createCreditModifier = require('./createCreditModifier');
+const createDiscountModifier = require('./createDiscountModifier');
+const createGroupValuesModifier = require('./createGroupValuesModifier');
+const createIndirectModifier = require('./createIndirectModifier');
+const createSubscriptionModifier = require('./createSubscriptionModifier');
+const displayAsCard = require('./displayAsCard');
+const displayAsChips = require('./displayAsChips');
+const displayAsList = require('./displayAsList');
+const duplicate = require('./duplicate');
+const enableAutoPopup = require('./enableAutoPopup');
+const filterByRequiredModifiers = require('./filterByRequiredModifiers');
+const findById = require('./findById');
+const findByPaymentMethod = require('./findByPaymentMethod');
+const findByPaymentType = require('./findByPaymentType');
+const getAvailablePromotions = require('./getAvailablePromotions');
+const getAvailablePromotionsOrSubscriptions = require('./getAvailablePromotionsOrSubscriptions');
+const getAvailableSubscriptions = require('./getAvailableSubscriptions');
+const getByAttribute = require('./getByAttribute');
+const getCreditModifier = require('./getCreditModifier');
+const getDefaultModifiers = require('./getDefaultModifiers');
+const getDepartmentModifiers = require('./getDepartmentModifiers');
+const getDiscountModifiers = require('./getDiscountModifiers');
+const getDescription = require('./getDescription');
+const getDepartmentMaxItems = require('./getDepartmentMaxItems');
+const getDirectModifiers = require('./getDirectModifiers');
+const getDescriptions = require('./getDescriptions');
+const getEntityModifiers = require('./getEntityModifiers');
+const getExtendedTags = require('./getExtendedTags');
+const getEntityPromotions = require('./getEntityPromotions');
+const getFiles = require('./getFiles');
+const getGroupOfItemsModifiers = require('./getGroupOfItemsModifiers');
+const getGroupRelatedModifiers = require('./getGroupRelatedModifiers');
+const getGroupModifiers = require('./getGroupModifiers');
+const getImages = require('./getImages');
+const getItemModifiers = require('./getItemModifiers');
+const getInheritedModifiers = require('./getInheritedModifiers');
+const getLaundryModifiers = require('./getLaundryModifiers');
+const getMatchTagsModifiers = require('./getMatchTagsModifiers');
+const getModifierIndex = require('./getModifierIndex');
+const getPreferences = require('./getPreferences');
+const getPromotionModifiers = require('./getPromotionModifiers');
+const getPromptMessage = require('./getPromptMessage');
+const getProperty = require('./getProperty');
+const getRelatedModifiers = require('./getRelatedModifiers');
+const getRecommendedModifiers = require('./getRecommendedModifiers');
+const getRequiredModifiers = require('./getRequiredModifiers');
+const getSelectedValues = require('./getSelectedValues');
+const getSubscriptionItem = require('./getSubscriptionItem');
+const getSubscriptionModifiers = require('./getSubscriptionModifiers');
+const getStarchModifier = require('./getStarchModifier');
+const getService = require('./getService');
+const getSplittedModifiers = require('./getSplittedModifiers');
+const getSuggestion = require('./getSuggestion');
+const getUnhiddenModifiers = require('./getUnhiddenModifiers');
+const getUsingCount = require('./getUsingCount');
+const hasAddModifiers = require('./hasAddModifiers');
+const hasAllTag = require('./hasAllTag');
+const hasAttribute = require('./hasAttribute');
+const hasAttributes = require('./hasAttributes');
+const hasCreateSubscription = require('./hasCreateSubscription');
+const hasDisplayPrompt = require('./hasDisplayPrompt');
+const hasMatchTags = require('./hasMatchTags');
+const hasModifier = require('./hasModifier');
+const hasRelatedItems = require('./hasRelatedItems');
+const includePiecesInQuantity = require('./includePiecesInQuantity');
+const includesInGroup = require('./includesInGroup');
+const isTrackUsageSubscription = require('./isTrackUsageSubscription');
+const isDirect = require('./isDirect');
+const hasNoTags = require('./hasNoTags');
+const isRemoveModifier = require('./isRemoveModifier');
+const isGroupOfModifiers = require('./isGroupOfModifiers');
+const isRequiredAndOverride = require('./isRequiredAndOverride');
+const isManual = require('./isManual');
+const isPriceOverride = require('./isPriceOverride');
+const isQuantityOverride = require('./isQuantityOverride');
+const isService = require('./isService');
+const isSingleValue = require('./isSingleValue');
+const isGroupOfItems = require('./isGroupOfItems');
+const isOverride = require('./isOverride');
+const isDepartment = require('./isDepartment');
+const isRequired = require('./isRequired');
+const isMultiplier = require('./isMultiplier');
+const isAvailablePromotion = require('./isAvailablePromotion');
+const isAvailableSubscription = require('./isAvailableSubscription');
+const isPromotion = require('./isPromotion');
+const isSubscription = require('./isSubscription');
+const isDefault = require('./isDefault');
+const isIncluded = require('./isIncluded');
+const isCustomerTagsExtend = require('./isCustomerTagsExtend');
+const isAmountOverride = require('./isAmountOverride');
+const isDiscount = require('./isDiscount');
+const isHidden = require('./isHidden');
+const isGratuity = require('./isGratuity');
+const isPaymentMethods = require('./isPaymentMethods');
+const isPaymentTypes = require('./isPaymentTypes');
+const isPreferences = require('./isPreferences');
+const isGroupOfValues = require('./isGroupOfValues');
+const isCompact = require('./isCompact');
+const isValueSelected = require('./isValueSelected');
+const isEditable = require('./isEditable');
+const isCredit = require('./isCredit');
+const purifyModifiers = require('./purifyModifiers');
+const sort = require('./sort');
+
+const modifierActions = (deps = {}) => {
+  const actions = {};
+
+  const innerDeps = {
+    ...deps,
+    actions,
+  };
+
+  const freezedActions = Object.freeze({
+    addFile: addFile(innerDeps),
+    addImage: addImage(innerDeps),
+    calculate: calculate(innerDeps),
+    contains: contains(innerDeps),
+    convertMenuModifiers: convertMenuModifiers(innerDeps),
+    create: create(innerDeps),
+    createAmountOverrideModifier: createAmountOverrideModifier(innerDeps),
+    createCreditModifier: createCreditModifier(innerDeps),
+    createDiscountModifier: createDiscountModifier(innerDeps),
+    createGroupValuesModifier: createGroupValuesModifier(innerDeps),
+    createIndirectModifier: createIndirectModifier(innerDeps),
+    createSubscriptionModifier: createSubscriptionModifier(innerDeps),
+    displayAsCard: displayAsCard(innerDeps),
+    displayAsChips: displayAsChips(innerDeps),
+    displayAsList: displayAsList(innerDeps),
+    duplicate: duplicate(innerDeps),
+    enableAutoPopup: enableAutoPopup(innerDeps),
+    filterByRequiredModifiers: filterByRequiredModifiers(innerDeps),
+    findById: findById(innerDeps),
+    findByPaymentMethod: findByPaymentMethod(innerDeps),
+    findByPaymentType: findByPaymentType(innerDeps),
+    getAvailablePromotions: getAvailablePromotions(innerDeps),
+    getAvailablePromotionsOrSubscriptions:
+      getAvailablePromotionsOrSubscriptions(innerDeps),
+    getAvailableSubscriptions: getAvailableSubscriptions(innerDeps),
+    getByAttribute: getByAttribute(innerDeps),
+    getCreditModifier: getCreditModifier(innerDeps),
+    getDepartmentMaxItems: getDepartmentMaxItems(innerDeps),
+    getDirectModifiers: getDirectModifiers(innerDeps),
+    getDescriptions: getDescriptions(innerDeps),
+    getDepartmentModifiers: getDepartmentModifiers(innerDeps),
+    getDiscountModifiers: getDiscountModifiers(innerDeps),
+    getDescription: getDescription(innerDeps),
+    getDefaultModifiers: getDefaultModifiers(innerDeps),
+    getEntityModifiers: getEntityModifiers(innerDeps),
+    getExtendedTags: getExtendedTags(innerDeps),
+    getEntityPromotions: getEntityPromotions(innerDeps),
+    getFiles: getFiles(innerDeps),
+    getGroupRelatedModifiers: getGroupRelatedModifiers(innerDeps),
+    getGroupModifiers: getGroupModifiers(innerDeps),
+    getGroupOfItemsModifiers: getGroupOfItemsModifiers(innerDeps),
+    getImages: getImages(innerDeps),
+    getInheritedModifiers: getInheritedModifiers(innerDeps),
+    getItemModifiers: getItemModifiers(innerDeps),
+    getLaundryModifiers: getLaundryModifiers(innerDeps),
+    getMatchTagsModifiers: getMatchTagsModifiers(innerDeps),
+    getModifierIndex: getModifierIndex(innerDeps),
+    getPreferences: getPreferences(innerDeps),
+    getPromotionModifiers: getPromotionModifiers(innerDeps),
+    getPromptMessage: getPromptMessage(innerDeps),
+    getProperty: getProperty(innerDeps),
+    getRelatedModifiers: getRelatedModifiers(innerDeps),
+    getRecommendedModifiers: getRecommendedModifiers(innerDeps),
+    getRequiredModifiers: getRequiredModifiers(innerDeps),
+    getSelectedValues: getSelectedValues(innerDeps),
+    getSubscriptionItem: getSubscriptionItem(innerDeps),
+    getSubscriptionModifiers: getSubscriptionModifiers(innerDeps),
+    getStarchModifier: getStarchModifier(innerDeps),
+    getService: getService(innerDeps),
+    getSplittedModifiers: getSplittedModifiers(innerDeps),
+    getSuggestion: getSuggestion(innerDeps),
+    getUnhiddenModifiers: getUnhiddenModifiers(innerDeps),
+    getUsingCount: getUsingCount(innerDeps),
+    hasAddModifiers: hasAddModifiers(innerDeps),
+    hasAllTag: hasAllTag(innerDeps),
+    hasNoTags: hasNoTags(innerDeps),
+    hasCreateSubscription: hasCreateSubscription(innerDeps),
+    hasDisplayPrompt: hasDisplayPrompt(innerDeps),
+    hasMatchTags: hasMatchTags(innerDeps),
+    hasModifier: hasModifier(innerDeps),
+    hasRelatedItems: hasRelatedItems(innerDeps),
+    hasAttribute: hasAttribute(innerDeps),
+    hasAttributes: hasAttributes(innerDeps),
+    includePiecesInQuantity: includePiecesInQuantity(innerDeps),
+    includesInGroup: includesInGroup(innerDeps),
+    isTrackUsageSubscription: isTrackUsageSubscription(innerDeps),
+    isDirect: isDirect(innerDeps),
+    isEditable: isEditable(innerDeps),
+    isRemoveModifier: isRemoveModifier(innerDeps),
+    isGroupOfModifiers: isGroupOfModifiers(innerDeps),
+    isRequiredAndOverride: isRequiredAndOverride(innerDeps),
+    isManual: isManual(innerDeps),
+    isService: isService(innerDeps),
+    isQuantityOverride: isQuantityOverride(innerDeps),
+    isPriceOverride: isPriceOverride(innerDeps),
+    isSingleValue: isSingleValue(innerDeps),
+    isGroupOfItems: isGroupOfItems(innerDeps),
+    isOverride: isOverride(innerDeps),
+    isDepartment: isDepartment(innerDeps),
+    isRequired: isRequired(innerDeps),
+    isMultiplier: isMultiplier(innerDeps),
+    isAvailablePromotion: isAvailablePromotion(innerDeps),
+    isAvailableSubscription: isAvailableSubscription(innerDeps),
+    isPromotion: isPromotion(innerDeps),
+    isSubscription: isSubscription(innerDeps),
+    isDefault: isDefault(innerDeps),
+    isCustomerTagsExtend: isCustomerTagsExtend(innerDeps),
+    isAmountOverride: isAmountOverride(innerDeps),
+    isDiscount: isDiscount(innerDeps),
+    isHidden: isHidden(innerDeps),
+    isGratuity: isGratuity(innerDeps),
+    isPaymentMethods: isPaymentMethods(innerDeps),
+    isPaymentTypes: isPaymentTypes(innerDeps),
+    isPreferences: isPreferences(innerDeps),
+    isGroupOfValues: isGroupOfValues(innerDeps),
+    isCompact: isCompact(innerDeps),
+    isValueSelected: isValueSelected(innerDeps),
+    isCredit: isCredit(innerDeps),
+    isIncluded: isIncluded(innerDeps),
+    purifyModifiers: purifyModifiers(innerDeps),
+    sort: sort(innerDeps),
+  });
+
+  Object.keys(freezedActions).forEach(actionName => {
+    actions[actionName] = freezedActions[actionName];
+  });
+
+  return freezedActions;
+};
+
+module.exports = modifierActions;

package/lib/modifier/isAmountOverride.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function isAmountOverride(modifier) {
+    return (
+      actions.isOverride(modifier) &&
+      modifier.properties.override.field === 'amount'
+    );
+  };

package/lib/modifier/isAvailablePromotion.js

@@ -0,0 +1,23 @@
+module.exports = ({ utils, actions }) => {
+  const { date, math } = utils;
+
+  return function isAvailablePromotion(modifier) {
+    if (!actions.isPromotion(modifier)) return false;
+
+    const { promotion } = modifier.properties || {};
+
+    if (!promotion) return true;
+
+    if (
+      promotion.numberOfUses &&
+      promotion.numberOfUsesLimit &&
+      math.gte(promotion.numberOfUses, promotion.numberOfUsesLimit)
+    )
+      return false;
+
+    if (promotion.dateLimit && !date.isBetween(promotion.dateLimit))
+      return false;
+
+    return true;
+  };
+};

package/lib/modifier/isAvailableSubscription.js

@@ -0,0 +1,28 @@
+module.exports = ({ utils, actions }) => {
+  const { date, math } = utils;
+
+  return function isAvailableSubscription(modifier) {
+    if (!actions.isSubscription(modifier)) return false;
+
+    const { subscription } = modifier.properties || {};
+
+    if (!subscription) return false;
+
+    const properties = {
+      ...subscription.item,
+      dateLimit: subscription.dateLimit,
+    };
+
+    if (
+      properties.numberOfUses &&
+      properties.numberOfUsesLimit &&
+      math.gte(properties.numberOfUses, properties.numberOfUsesLimit)
+    )
+      return false;
+
+    if (properties.dateLimit && !date.isBetween(properties.dateLimit))
+      return false;
+
+    return true;
+  };
+};

package/lib/modifier/isCompact.js

@@ -0,0 +1,12 @@
+module.exports = ({ actions, constants }) => {
+  const { Modifier } = constants;
+  return function isCompact(modifier) {
+    const { properties = {} } = modifier || {};
+    return !!(
+      actions.hasAttribute(modifier, Modifier.Attributes.GROUP) &&
+      properties &&
+      properties.group &&
+      properties.group.compact
+    );
+  };
+};

package/lib/modifier/isCredit.js

@@ -0,0 +1,6 @@
+module.exports = ({ constants }) => {
+  const { Modifier } = constants;
+  return function isCredit(modifier) {
+    return !!(modifier && modifier.type === Modifier.Types.CREDIT);
+  };
+};

package/lib/modifier/isCustomerTagsExtend.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function isCustomerTagsExtend(modifier) {
+    return (
+      modifier &&
+      modifier.properties &&
+      modifier.properties.department &&
+      (modifier.properties.department.customerTagsExtend || []).length
+    );
+  };

package/lib/modifier/isDefault.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isDefault(modifier) {
+    return modifier && modifier.default;
+  };

package/lib/modifier/isDepartment.js

@@ -0,0 +1,6 @@
+module.exports = ({ actions, constants }) => {
+  const { Modifier } = constants;
+  return function isDepartment(modifier) {
+    return actions.hasAttribute(modifier, Modifier.Attributes.DEPARTMENT);
+  };
+};

package/lib/modifier/isDirect.js

@@ -0,0 +1,6 @@
+module.exports = () =>
+  function isDirect(modifier) {
+    if (!modifier) return false;
+
+    return modifier.direct;
+  };

package/lib/modifier/isDiscount.js

@@ -0,0 +1,6 @@
+module.exports = ({ constants }) => {
+  const { Modifier } = constants;
+  return function isDiscount(modifier) {
+    return !!(modifier && modifier.type === Modifier.Types.DISCOUNT);
+  };
+};

package/lib/modifier/isEditable.js

@@ -0,0 +1,10 @@
+module.exports = ({ actions }) =>
+  function isEditable(modifier) {
+    const { properties = {} } = modifier || {};
+    return !!(
+      actions.isGroupOfValues(modifier) &&
+      properties &&
+      properties.group &&
+      properties.group.editGroupValues
+    );
+  };

package/lib/modifier/isGratuity.js

@@ -0,0 +1,6 @@
+module.exports = ({ constants }) => {
+  const { Modifier } = constants;
+  return function isGratuity(modifier) {
+    return !!(modifier && modifier.type === Modifier.Types.GRATUITY);
+  };
+};

package/lib/modifier/isGroupOfItems.js

@@ -0,0 +1,12 @@
+module.exports = ({ actions, constants }) => {
+  const { Modifier } = constants;
+  return function isGroupOfItems(modifier) {
+    const { properties = {} } = modifier || {};
+    return !!(
+      actions.hasAttribute(modifier, Modifier.Attributes.GROUP) &&
+      properties &&
+      properties.group &&
+      (properties.group.items || []).length
+    );
+  };
+};