@darkpos/pricing 1.0.43 → 1.0.45

package/lib/modifier/validateRequiredModifiers.js

@@ -0,0 +1,16 @@
+module.exports = ({ actions, _ }) =>
+  function validateRequiredModifiers(modifiers, requiredModifiers, operand) {
+    if (_.isEmpty(requiredModifiers) && !operand) return true;
+    switch (operand) {
+      case '$in':
+        return requiredModifiers.some(each =>
+          actions.contains(modifiers, each)
+        );
+      case '$nin':
+        return requiredModifiers.every(
+          each => !actions.contains(modifiers, each)
+        );
+      default:
+        return false;
+    }
+  };

package/lib/order/addItemModifier.js

@@ -27,31 +27,71 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     return false;
   };
 
-  const validateItemPiecesCondition = (itemPieces, minPieces) => {
-    if (!minPieces) return true;
-    return minPieces <= itemPieces;
-  };
-
-  const validateItemQtyCondition = (itemQuantity, minQuantity) => {
-    if (!minQuantity) return true;
-    return minQuantity <= itemQuantity;
-  };
-
-  const validateRequiredModifiers = (modifiers, requiredModifiers) => {
-    if (_.isEmpty(modifiers) || _.isEmpty(requiredModifiers)) return true;
-    return requiredModifiers.every(each =>
-      modifierActions.contains(modifiers, each)
-    );
-  };
-
   const areConditionsMet = (item, conditions) => {
-    if (!conditions) return true;
-
-    return (
-      validateItemPiecesCondition(item.pieces, conditions.minItemPieces) &&
-      validateItemQtyCondition(item.quantity, conditions.minItemQuantity) &&
-      validateRequiredModifiers(item.modifiers, conditions.modifiers)
+    const conditionsBag = [];
+    if (!conditions || !conditions.rules) return conditionsBag;
+    // Find conditions with itemPieces as key
+    const itemPiecesConditions = conditions.rules.filter(
+      each => each.key === 'itemPieces'
     );
+    if (itemPiecesConditions.length > 0) {
+      itemPiecesConditions.forEach(each => {
+        if (
+          !modifierActions.validateNumberCondition(
+            item.pieces,
+            each.value,
+            each.operand
+          )
+        ) {
+          conditionsBag.push({
+            name: `${each.operand}.itemPieces`,
+            value: each.value,
+            current: item.pieces,
+          });
+        }
+      });
+    }
+    const itemQtyConditions = conditions.rules.filter(
+      each => each.key === 'itemQuantity'
+    );
+    if (itemQtyConditions.length > 0) {
+      itemQtyConditions.forEach(each => {
+        if (
+          !modifierActions.validateNumberCondition(
+            item.quantity,
+            each.value,
+            each.operand
+          )
+        ) {
+          conditionsBag.push({
+            name: `${each.operand}.itemQuantity`,
+            value: each.value,
+            current: item.quantity,
+          });
+        }
+      });
+    }
+    const requiredModifiersConditions = conditions.rules.filter(
+      each => each.key === 'modifiers'
+    );
+    if (requiredModifiersConditions.length > 0) {
+      requiredModifiersConditions.forEach(each => {
+        if (
+          !modifierActions.validateRequiredModifiers(
+            item.modifiers,
+            each.value,
+            each.operand
+          )
+        ) {
+          conditionsBag.push({
+            name: `${each.operand}.modifiers`,
+            value: each.value,
+            current: item.modifiers,
+          });
+        }
+      });
+    }
+    return conditionsBag;
   };
 
   const addModifier = ({
@@ -63,19 +103,21 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
       items: [],
       itemModifiers: [],
     },
+    onConditionsNotMet,
   }) => {
     const modifier = _modifier; // to avoid no param reassign lint rule
     let item = { ...itemProp };
     const compute = getComputeModField(modifier);
     if (hasBehaivoralFields(modifier)) return item;
-    // check conditions
-    if (!areConditionsMet(item, modifier.conditions)) return item;
+    const conditionsBag = areConditionsMet(item, modifier.conditions);
     const isAmountOverride = modifierActions.isAmountOverride(modifier);
     const isPriceOverride = modifierActions.isPriceOverride(modifier);
-
-    // change modifier compute based on onverride and creates a clone of  the modifier
+    // is the modifier suggestion required
+    if (conditionsBag.length > 0 && !modifierActions.isRequired(modifier)) {
+      if (onConditionsNotMet) onConditionsNotMet(conditionsBag);
+      return item;
+    }
     const modifierToAdd = modifierActions.mutateModifier(modifier);
-
     const modifierIndex = item.modifiers.findIndex(
       ieach => ieach.modifierId === modifier._id
     );
@@ -122,6 +164,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     modifier,
     itemIndex,
     cache,
+    onConditionsNotMet,
   }) {
     let order = _.cloneDeep(orderProp);
     if (!order || itemIndex < 0 || !modifier) return order;
@@ -166,6 +209,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
       modifier,
       cache,
       customer,
+      onConditionsNotMet,
     });
 
     // Recursive Rules:

package/lib/order/applyPayment.js

@@ -0,0 +1,61 @@
+/**
+  const options = {
+    "5d9f80ae6065e52e04686e03": {
+      amount: 10,
+      items: {
+        "5d9f80dc6065e52e04686e3c": {
+          status: { picked: { value: true } },
+          total: 0,
+          totalPaid: 5,
+        },
+        "5d9f80dc6065e52e04686e3c": {
+          status: { picked: { value: true } },
+          total: 0,
+          totalPaid: 5,
+        },
+        "5d9f80dc6065e52e04686e3c": {
+          status: { picked: { value: true } },
+          total: 0,
+          totalPaid: 5,
+        },
+        "5d9f80dc6065e52e04686e3c": {
+          status: { picked: { value: true } },
+          total: 0,
+          totalPaid: 5,
+        },
+      }
+    }
+  }
+ */
+module.exports = ({ utils, itemActions }) =>
+  function applyPayment(options, amountToProcess = 0) {
+    const optionsWithAmount = options;
+    let amount = amountToProcess;
+
+    Object.keys(options).forEach(orderId => {
+      const order = options[orderId];
+      const { items } = order;
+
+      Object.keys(items).forEach(itemId => {
+        const item = items[itemId];
+
+        const { amountToAssign, remainingAmount, isPaid } =
+          itemActions.getAmounts(item, amount);
+        amount = remainingAmount;
+
+        // assign amount to item
+        items[itemId] = {
+          ...item,
+          orderId,
+          amount: amountToAssign,
+          totalPaid: utils.math.add(item.totalPaid, amountToAssign),
+          status: {
+            ...item.status,
+            paid: { value: isPaid, date: new Date() },
+          },
+        };
+      });
+    });
+
+    return optionsWithAmount;
+  };

package/lib/order/calculate.js

@@ -2,37 +2,47 @@
 /**
  * return calculated Order
  */
-module.exports = ({ _, actions, itemActions, modifierActions }) =>
-  function calculateorder(inputOrder) {
+module.exports = ({ _, actions, itemActions, modifierActions, utils }) =>
+  function calculateorder(inputOrder, opts = {}) {
     if (!inputOrder) return inputOrder;
     const order = _.cloneDeep(inputOrder);
     const { items = [], orders = [] } = order;
-
     if (!items.length) {
       if (!orders.length)
         return { ...order, subTotals: {}, subTotal: 0, total: 0 };
 
       return { ...order, ...actions.getTotals(order.orders) };
     }
-
-    const sortedOrderModifiers = modifierActions.sort(
-      modifierActions.removeLocked(order.modifiers)
-    );
+    const startRequestDate = order.start ? order.start.requestDate : null;
+    const endRequestDate = order.end ? order.end.requestDate : null;
+    const options = {
+      ...opts,
+      startRequestDate,
+      endRequestDate,
+    };
+    const sortedOrderModifiers = modifierActions.sort(order.modifiers || []);
 
     let itemsWNIM = items.map(item =>
       itemActions.removeModifiers({ item, modifiers: sortedOrderModifiers })
     );
 
-    itemsWNIM = itemActions.calculate(itemsWNIM);
+    itemsWNIM = itemActions.calculate(itemsWNIM, {
+      ...options,
+      lockPaymentModifiers: !!(
+        options.lockPaymentModifiers && !sortedOrderModifiers.length
+      ),
+    });
 
     const newOrder = {
       ...order,
-      ...itemActions.getTotals(itemsWNIM),
+      ...itemActions.getItemsTotals(itemsWNIM),
       items: itemsWNIM,
     };
 
     if (!sortedOrderModifiers.length) return newOrder;
 
+    itemsWNIM = itemActions.calculate(itemsWNIM, {});
+
     let tempItems = itemsWNIM || items;
     let itemsWIM = _.cloneDeep(tempItems);
     let prvSort = null;
@@ -55,26 +65,19 @@ module.exports = ({ _, actions, itemActions, modifierActions }) =>
         } else {
           tempItems = itemsWIM;
         }
-        tempItems = itemActions.calculate(tempItems);
+        tempItems = itemActions.calculate(tempItems, options);
       }
 
       if (isCredit) {
-        const calculatedItemWIM = itemActions.calculate(itemsWIM);
-        computedTotal = itemActions.getTotals(calculatedItemWIM).total;
+        const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
+        computedTotal = itemActions.getItemsTotals(calculatedItemWIM).total;
       }
 
       if (modifierActions.hasItems({ modifier })) {
         tempItems = itemActions.getItems(tempItems, modifier.items);
       }
 
-      tempItems = tempItems.map(tempItem =>
-        itemActions.removeModifiers({
-          item: tempItem,
-          modifiers: modifierActions.getLockedModifiers(tempItem.modifiers),
-        })
-      );
-
-      computedTotal = itemActions.getTotals(tempItems).total;
+      computedTotal = itemActions.getItemsTotals(tempItems).total;
 
       const itemsModifiers = itemActions.addIndirectModifier({
         orderTotal: computedTotal,
@@ -92,11 +95,31 @@ module.exports = ({ _, actions, itemActions, modifierActions }) =>
       prvSort = sort;
     }
 
-    const calculatedItemWIM = itemActions.calculate(itemsWIM);
+    const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
+
+    if (calculatedItemWIM.length > 1) {
+      const { total, subTotalsTotal } = calculatedItemWIM.reduce(
+        (acc, item) => ({
+          total: utils.math.add(acc.total, item.total),
+          subTotalsTotal: utils.math.add(
+            acc.subTotalsTotal,
+            utils.math.add(item.subTotals._actual, item.subTotals._xincluded)
+          ),
+        }),
+        { total: 0, subTotalsTotal: 0 }
+      );
+      const difference = utils.math.sub(subTotalsTotal, total);
+
+      if (difference > 0) {
+        calculatedItemWIM[0].total = utils.math.toDecimalPlaces(
+          utils.math.add(calculatedItemWIM[0].total, difference)
+        );
+      }
+    }
 
     return {
       ...order,
-      ...itemActions.getTotals(calculatedItemWIM),
+      ...itemActions.getItemsTotals(calculatedItemWIM),
       items: calculatedItemWIM,
     };
   };

package/lib/order/getBalance.js

@@ -3,7 +3,6 @@ module.exports = ({ utils }) => {
   return function getBalance({ order }) {
     if (!order) return 0;
     if (Array.isArray(order)) return 0;
-
     return math.sub(order.total, order.totalPaid);
   };
 };

package/lib/order/getOrdersBalance.js

@@ -0,0 +1,8 @@
+module.exports = ({ utils, actions }) =>
+  function getOrdersBalance({ orders = [] }) {
+    const result = orders.reduce(
+      (acc, order) => utils.math.add(acc, actions.getBalance({ order })),
+      0
+    );
+    return result;
+  };

package/lib/order/index.js

@@ -1,7 +1,7 @@
 //
 const getTotalPieces = require('./getTotalPieces');
 const getStartDate = require('./getStartDate');
-const getBalance = require('./getBalance');
+const getOrdersBalance = require('./getOrdersBalance');
 const getEndDate = require('./getEndDate');
 const isNew = require('./isNew');
 const getSelectedItem = require('./getSelectedItem');
@@ -57,8 +57,6 @@ const removeApplyModifier = require('./removeApplyModifier');
 const getCustomerSubscriptions = require('./getCustomerSubscriptions');
 const getCustomerSubscriptionsByItem = require('./getCustomerSubscriptionsByItem');
 const hasRemainingSubscription = require('./hasRemainingSubscription');
-const removeModifiersWithPaymentMethods = require('./removeModifiersWithPaymentMethods');
-const removeModifiersWithPaymentTypes = require('./removeModifiersWithPaymentTypes');
 const getItemsToPay = require('./getItemsToPay');
 const hasItem = require('./hasItem');
 const getNumberOfItems = require('./getNumberOfItems');
@@ -72,7 +70,6 @@ const getItemIndex = require('./getItemIndex');
 const getRelatedItems = require('./getRelatedItems');
 const getItemByItemId = require('./getItemByItemId');
 const getScheduleByCustomer = require('./getScheduleByCustomer');
-const pickEndDate = require('./pickEndDate');
 const getAppliedCredit = require('./getAppliedCredit');
 const addCreditModifier = require('./addCreditModifier');
 const adjustCreditModifiersDifference = require('./adjustCreditModifiersDifference');
@@ -83,11 +80,14 @@ const splitAndCalculate = require('./splitAndCalculate');
 const spreadModifiers = require('./spreadModifiers');
 const validateCreditModifiersTotal = require('./validateCreditModifiersTotal');
 const validateFixedModifiersTotal = require('./validateFixedModifiersTotal');
-const markModifiersAsLocked = require('./markModifiersAsLocked');
 const removeModifiers = require('./removeModifiers');
 const addModifiers = require('./addModifiers');
 const createSuborder = require('./createSuborder');
 const getSuborder = require('./getSuborder');
+const manualSplit = require('./manualSplit');
+const manualSplitByQuantity = require('./manualSplitByQuantity');
+const applyPayment = require('./applyPayment');
+const getBalance = require('./getBalance');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -157,9 +157,6 @@ const orderActions = (deps = {}) => {
     getCustomerSubscriptions: getCustomerSubscriptions(innerDeps),
     getCustomerSubscriptionsByItem: getCustomerSubscriptionsByItem(innerDeps),
     hasRemainingSubscription: hasRemainingSubscription(innerDeps),
-    removeModifiersWithPaymentMethods:
-      removeModifiersWithPaymentMethods(innerDeps),
-    removeModifiersWithPaymentTypes: removeModifiersWithPaymentTypes(innerDeps),
     hasItem: hasItem(innerDeps),
     getNumberOfItems: getNumberOfItems(innerDeps),
     isOpen: isOpen(innerDeps),
@@ -172,7 +169,6 @@ const orderActions = (deps = {}) => {
     getItemIndex: getItemIndex(innerDeps),
     getRelatedItems: getRelatedItems(innerDeps),
     getScheduleByCustomer: getScheduleByCustomer(innerDeps),
-    pickEndDate: pickEndDate(innerDeps),
     getAppliedCredit: getAppliedCredit(innerDeps),
     addCreditModifier: addCreditModifier(innerDeps),
     adjustCreditModifiersDifference: adjustCreditModifiersDifference(innerDeps),
@@ -183,11 +179,14 @@ const orderActions = (deps = {}) => {
     spreadModifiers: spreadModifiers(innerDeps),
     validateCreditModifiersTotal: validateCreditModifiersTotal(innerDeps),
     validateFixedModifiersTotal: validateFixedModifiersTotal(innerDeps),
-    markModifiersAsLocked: markModifiersAsLocked(innerDeps),
     removeModifiers: removeModifiers(innerDeps),
     addModifiers: addModifiers(innerDeps),
     createSuborder: createSuborder(innerDeps),
     getSuborder: getSuborder(innerDeps),
+    manualSplit: manualSplit(innerDeps),
+    manualSplitByQuantity: manualSplitByQuantity(innerDeps),
+    applyPayment: applyPayment(innerDeps),
+    getOrdersBalance: getOrdersBalance(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/manualSplit.js

@@ -0,0 +1,34 @@
+module.exports = ({ actions }) =>
+  function manualSplit(
+    { orderIndex, itemIndex },
+    destinationIndex,
+    currentOrder,
+    subOrders,
+    itemId,
+    splitQuantity
+  ) {
+    let _subOrders = subOrders;
+
+    if (
+      orderIndex == null ||
+      itemIndex == null ||
+      subOrders == null ||
+      destinationIndex == null
+    )
+      return _subOrders;
+    if (!subOrders[destinationIndex] || !subOrders[orderIndex])
+      return _subOrders;
+    if (splitQuantity) {
+      _subOrders = actions.manualSplitByQuantity(
+        { orderIndex, itemIndex },
+        destinationIndex,
+        currentOrder,
+        subOrders,
+        itemId
+      );
+    } else {
+      const item = _subOrders[orderIndex].items.splice(itemIndex, 1)[0];
+      if (item) _subOrders[destinationIndex].items.unshift(item);
+    }
+    return _subOrders.map(subOrder => actions.calculate(subOrder));
+  };

package/lib/order/manualSplitByQuantity.js

@@ -0,0 +1,50 @@
+module.exports = () =>
+  function splitByQuantity(
+    { orderIndex, itemIndex },
+    destinationIndex,
+    currentOrder,
+    subOrders,
+    itemId
+  ) {
+    const _subOrders = subOrders;
+    const currentItem = currentOrder.items.find(item => item._id === itemId);
+    const currentSuborder = subOrders[Number(orderIndex)];
+    const currentSuborderItem = (currentSuborder.items || []).find(
+      item => item._id === itemId
+    );
+    const destinationSuborder = subOrders[Number(destinationIndex)];
+    let destinationItem = (destinationSuborder.items || []).find(
+      item => item._id === itemId
+    );
+    if (orderIndex !== destinationIndex) {
+      for (let i = 0; i <= subOrders.length; i += 1) {
+        if (i === orderIndex) {
+          if (currentSuborderItem && currentSuborder && currentSuborder.items) {
+            // react breaks if I don't create a clone to reassign the quantity
+            const _currentSuborderItem = { ...currentSuborderItem };
+            _currentSuborderItem.quantity =
+              Number(_currentSuborderItem.quantity) - 1;
+            currentSuborder.items[Number(itemIndex)] = _currentSuborderItem;
+            if (Number(_currentSuborderItem.quantity) <= 0) {
+              currentSuborder.items.splice(Number(itemIndex), 1);
+            }
+            _subOrders[Number(orderIndex)] = currentSuborder;
+          }
+        }
+
+        if (i === destinationIndex) {
+          // case 1: if the suborder has no items
+          if (!destinationItem) {
+            destinationItem = { ...currentItem, quantity: 1 };
+            destinationSuborder.items =
+              destinationSuborder.items.concat(destinationItem);
+          } else {
+            // case 2: if the suborder has items
+            destinationItem.quantity = Number(destinationItem.quantity) + 1;
+          }
+          _subOrders[Number(destinationIndex)] = destinationSuborder;
+        }
+      }
+    }
+    return _subOrders;
+  };

package/lib/store/getRecommendedEndDate.js

@@ -0,0 +1,13 @@
+module.exports = ({ actions, settings }) =>
+  function getRecommendedEndDate() {
+    const defaultSchedule =
+      settings.order &&
+      settings.order.endDate &&
+      settings.order.endDate.default;
+
+    return defaultSchedule
+      ? actions.pickEndDate({
+          ...defaultSchedule,
+        })
+      : null;
+  };

package/lib/store/index.js

@@ -0,0 +1,25 @@
+//
+const pickEndDate = require('./pickEndDate');
+const getRecommendedEndDate = require('./getRecommendedEndDate');
+
+const storeActions = (deps = {}) => {
+  const actions = {};
+
+  const innerDeps = {
+    ...deps,
+    actions,
+  };
+
+  const freezedActions = Object.freeze({
+    pickEndDate: pickEndDate(innerDeps),
+    getRecommendedEndDate: getRecommendedEndDate(innerDeps),
+  });
+
+  Object.keys(freezedActions).forEach(actionName => {
+    actions[actionName] = freezedActions[actionName];
+  });
+
+  return freezedActions;
+};
+
+module.exports = storeActions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.43",
+  "version": "1.0.45",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -12,8 +12,10 @@
   "main": "index.js",
   "scripts": {
     "test": "jest --runInBand --detectOpenHandles --logHeapUsage --verbose --forceExit ./__TEST__",
-    "test:me": "jest --runInBand --detectOpenHandles --logHeapUsage --verbose --forceExit",
-    "lint": "eslint --quiet --fix lib/"
+    "test:me": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/order-payment-modifier.test.js",
+    "test:order": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/order.test.js",
+    "test:validateConditions": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/validateConditionsCalculate.test.js",
+    "lint": "eslint --quiet lib/"
   },
   "publishConfig": {
     "access": "public"
@@ -36,5 +38,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "60a1eef3eb458c750cda95b701904c8ea7e68157"
+  "gitHead": "3bfaa3655ef26d0dc0fb60bdc40caee1e3693ccb"
 }

package/lib/item/getBalanceToPay.js

@@ -1,12 +0,0 @@
-module.exports = ({ utils, actions }) =>
-  function getBalanceToPay({ orderItems = [] }) {
-    const total = orderItems.reduce(
-      (t, item) => utils.math.add(actions.getTotal(item), t),
-      0
-    );
-    const totalPaid = orderItems.reduce(
-      (t, item) => utils.math.add(t, item && item.totalPaid),
-      0
-    );
-    return utils.math.toDecimalPlaces(utils.math.sub(total, totalPaid));
-  };

package/lib/item/getTotals.js

@@ -1,40 +0,0 @@
-/* eslint-disable no-restricted-syntax */
-
-module.exports = ({ utils }) => {
-  const { math } = utils;
-  return function getTotals(items) {
-    let subTotals = {};
-    let subTotal = 0;
-
-    for (const item of items) {
-      subTotal = math.add(subTotal, item.subTotals._actual);
-      const keys = Object.keys(item.subTotals).filter(
-        key => !key.includes('_')
-      );
-      for (const key of keys) {
-        subTotals[key] = math.add(subTotals[key] || 0, item.subTotals[key]);
-      }
-    }
-
-    const total = math.toDecimalPlaces(
-      Object.keys(subTotals).reduce(
-        (acc, key) => math.add(acc, subTotals[key]),
-        subTotal
-      )
-    );
-
-    subTotals = Object.keys(subTotals).reduce(
-      (acc, key) => ({
-        ...acc,
-        [key]: math.toDecimalPlaces(subTotals[key]),
-      }),
-      {}
-    );
-
-    return {
-      subTotals,
-      subTotal,
-      total,
-    };
-  };
-};

package/lib/item/markModifiersAsLocked.js

@@ -1,11 +0,0 @@
-module.exports = () =>
-  function markModifiersAsLocked({ item, modifierIds }) {
-    if (!item || !Array.isArray(item.modifiers)) return {};
-
-    return {
-      ...item,
-      modifiers: item.modifiers.map(mod =>
-        modifierIds.includes(mod._parentId) ? { ...mod, locked: true } : mod
-      ),
-    };
-  };

package/lib/modifier/createPaymentModifier.js

@@ -1,12 +0,0 @@
-module.exports = ({ actions }) =>
-  function createPaymentModifier({
-    modifier = {},
-    items = [],
-    locked = false,
-  }) {
-    return {
-      ...actions.duplicate(modifier),
-      items,
-      locked,
-    };
-  };

package/lib/modifier/findByPaymentMethod.js

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