@darkpos/pricing 1.0.44 → 1.0.45

package/lib/item/calculate.js

@@ -1,13 +1,20 @@
+const { getComputeModField } = require('../modifier/utils');
+
 /* eslint-disable no-restricted-syntax */
 module.exports = ({ _, utils, actions, modifierActions }) => {
   const { math } = utils;
   //
-  const { getComputeModField } = require('../modifier/utils');
   const calculateOne = (inputItem, opts = {}) => {
     const item = _.cloneDeep(inputItem);
+    const amountToPay =
+      typeof opts.amountToPay === 'number' ? opts.amountToPay : 0;
     const paymentMethod = opts.paymentMethod || null;
+    const paymentType = opts.paymentType || null;
     const startRequestDate = opts.startRequestDate || null;
     const endRequestDate = opts.endRequestDate || null;
+    const lockPaymentModifiers = !!opts.lockPaymentModifiers;
+    const { paymentId } = opts;
+
     if (!item) return item;
 
     const subTotals = {
@@ -29,7 +36,6 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
     const validatedModifiers = itemModifiers.map(each =>
       modifierActions.validate(each, {
         item,
-        paymentMethod,
         startRequestDate,
         endRequestDate,
       })
@@ -47,20 +53,47 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         modifierActions.isValid(each)
     );
 
+    const paymentModifiersToCompute = validatedModifiers
+      .filter(
+        modifier =>
+          modifierActions.isPaymentModifier(modifier) &&
+          modifierActions.hasPaymentMethodType({
+            paymentModifier: modifier,
+            paymentMethod,
+            paymentType,
+          })
+      )
+      .filter(paymentModifier => {
+        const childModifiers = modifierActions.getChildren({
+          parentModifier: paymentModifier,
+          modifiers: modifiersToCompute,
+        });
+
+        return (
+          !modifierActions.isFixed(paymentModifier) ||
+          childModifiers.length === 0
+        );
+      });
+
     if (amountOverride) modifiersToCompute.push(amountOverride);
 
     const modifiersToNotCompute = validatedModifiers
       .filter(
         each =>
+          modifierActions.isPaymentModifier(each) ||
           !modifiersToCompute.find(
             ceach => ceach.modifierId === each.modifierId
           )
       )
       .map(each => modifierActions.calculate(each, { skip: true }));
 
-    if (modifiersToCompute.length) {
+    if (modifiersToCompute.length || paymentModifiersToCompute.length) {
       // sort modifiers based on sort
-      const sortedModifiers = modifierActions.sort(modifiersToCompute);
+      const sortedModifiers = modifierActions.sort([
+        ...modifiersToCompute,
+        ...paymentModifiersToCompute,
+      ]);
+
       let computedPrice = price;
       let prvPrice = 0;
       let prvSort;
@@ -76,12 +109,37 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
           prvSort = null;
         }
 
-        const _modifier = modifierActions.calculate(modifier, {
-          price: computedPrice,
-          quantity,
-        });
+        let _modifier = modifier;
+
+        if (modifierActions.isPaymentModifier(modifier)) {
+          _modifier = modifierActions.calculatePaymentModifier({
+            paymentModifier: modifier,
+            amountToPay,
+            itemBalance:
+              typeof item.totalPaid === 'number' && item.totalPaid > 0
+                ? actions.getItemsBalance({ items: [item] })
+                : math.sub(computedPrice, item.totalPaid),
+            paymentMethod,
+            paymentType,
+            paymentId,
+          });
+        }
+
+        _modifier = modifierActions.calculate(
+          { ..._modifier },
+          {
+            price: computedPrice,
+            quantity,
+          }
+        );
+
+        if (
+          !modifierActions.isPaymentModifier(modifier) ||
+          lockPaymentModifiers
+        ) {
+          modifiers.push(_modifier);
+        }
 
-        modifiers.push(_modifier);
         const { type, _computed } = _modifier;
 
         const computedAmountCalc = math.mul(_computed.amount, quantity);

package/lib/item/getAmounts.js

@@ -0,0 +1,14 @@
+module.exports = ({ utils }) =>
+  function getAmounts(item, amount) {
+    const { status = {}, total, totalPaid } = item;
+    const totalDue = utils.math.sub(total, totalPaid);
+    const remainingAmount = utils.math.sub(amount, totalDue);
+
+    if (status && status.paid && status.paid.value)
+      return { amountToAssign: 0, remainingAmount: amount, isPaid: true };
+
+    if (amount >= totalDue)
+      return { amountToAssign: totalDue, remainingAmount, isPaid: true };
+
+    return { amountToAssign: amount, remainingAmount: 0, isPaid: false };
+  };

package/lib/item/getBalance.js

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

package/lib/item/getItemsBalance.js

@@ -0,0 +1,9 @@
+module.exports = ({ utils, actions }) =>
+  function getItemsBalance({ items = [] }) {
+    const result = items.reduce(
+      (acc, item) => utils.math.add(acc, actions.getBalance({ item })),
+      0
+    );
+    console.log({ result });
+    return result;
+  };

package/lib/item/getItemsTotals.js

@@ -0,0 +1,27 @@
+/* eslint-disable no-restricted-syntax */
+
+module.exports = ({ utils }) => {
+  const { math } = utils;
+  return function getItemsTotals(items) {
+    const subTotals = {};
+    let subTotal = 0;
+    let total = 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], item.subTotals[key]);
+      }
+      total = math.add(total, item.total);
+    }
+
+    return {
+      subTotals,
+      subTotal,
+      total,
+    };
+  };
+};

package/lib/item/getTotal.js

@@ -2,6 +2,8 @@ module.exports = ({ utils }) => {
   const { math } = utils;
   return function getTotal(item) {
     if (!item || !item.subTotals) return 0;
-    return math.add(item.subTotals._actual, item.subTotals._xincluded);
+    return math.toDecimalPlaces(
+      math.add(item.subTotals._actual, item.subTotals._xincluded)
+    );
   };
 };

package/lib/item/hasPaymentMethodType.js

@@ -0,0 +1,17 @@
+module.exports = ({ modifierActions }) =>
+  function hasPaymentMethodType({ item, paymentMethod, paymentType }) {
+    if (
+      !item ||
+      !Array.isArray(item.modifiers) ||
+      (!paymentMethod && !paymentType)
+    )
+      return false;
+
+    return item.modifiers.some(modifier =>
+      modifierActions.hasPaymentMethodType({
+        paymentModifier: modifier,
+        paymentMethod,
+        paymentType,
+      })
+    );
+  };

package/lib/item/hasPaymentModifierWithPaymentId.js

@@ -0,0 +1,9 @@
+module.exports = ({ modifierActions }) =>
+  function hasPaymentModifierWithPaymentId({ item, paymentId }) {
+    if (!item || !Array.isArray(item.modifiers) || !paymentId) return false;
+
+    return item.modifiers.some(
+      modifier =>
+        modifierActions.getProperty(modifier, 'paymentId') === paymentId
+    );
+  };

package/lib/item/index.js

@@ -20,10 +20,9 @@ const removeModifierById = require('./removeModifierById');
 const getDiscountModifiers = require('./getDiscountModifiers');
 const getTotal = require('./getTotal');
 const getPendingIndex = require('./getPendingIndex');
-const getTotals = require('./getTotals');
+const getItemsTotals = require('./getItemsTotals');
 const getNotIncludedModifiers = require('./getNotIncludedModifiers');
 const hasModifierWithValue = require('./hasModifierWithValue');
-const getBalanceToPay = require('./getBalanceToPay');
 const getItemsTotalPaid = require('./getItemsTotalPaid');
 const getItemModifiersDescription = require('./getItemModifiersDescription');
 const isRelatedItem = require('./isRelatedItem');
@@ -31,12 +30,16 @@ const getParentItem = require('./getParentItem');
 const isParentIncluded = require('./isParentIncluded');
 const hasCreateSubscription = require('./hasCreateSubscription');
 const getItemModifiers = require('./getItemModifiers');
-const markModifiersAsLocked = require('./markModifiersAsLocked');
-const getBalance = require('./getBalance');
+const getItemsBalance = require('./getItemsBalance');
 const isFullyPaid = require('./isFullyPaid');
 const getTotalPrice = require('./getTotalPrice');
 const removePaymentModifiers = require('./removePaymentModifiers');
 const getItems = require('./getItems');
+const getAmounts = require('./getAmounts');
+const hasPaymentMethodType = require('./hasPaymentMethodType');
+const removePaymentModifiersByPaymentId = require('./removePaymentModifiersByPaymentId');
+const hasPaymentModifierWithPaymentId = require('./hasPaymentModifierWithPaymentId');
+const getBalance = require('./getBalance');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -69,10 +72,9 @@ const itemActions = (deps = {}) => {
     getDiscountModifiers: getDiscountModifiers(innerDeps),
     getTotal: getTotal(innerDeps),
     getPendingIndex: getPendingIndex(innerDeps),
-    getTotals: getTotals(innerDeps),
+    getItemsTotals: getItemsTotals(innerDeps),
     getNotIncludedModifiers: getNotIncludedModifiers(innerDeps),
     hasModifierWithValue: hasModifierWithValue(innerDeps),
-    getBalanceToPay: getBalanceToPay(innerDeps),
     getItemsTotalPaid: getItemsTotalPaid(innerDeps),
     getItemModifiersDescription: getItemModifiersDescription(innerDeps),
     isRelatedItem: isRelatedItem(innerDeps),
@@ -80,12 +82,17 @@ const itemActions = (deps = {}) => {
     isParentIncluded: isParentIncluded(innerDeps),
     hasCreateSubscription: hasCreateSubscription(innerDeps),
     getItemModifiers: getItemModifiers(innerDeps),
-    markModifiersAsLocked: markModifiersAsLocked(innerDeps),
-    getBalance: getBalance(innerDeps),
+    getItemsBalance: getItemsBalance(innerDeps),
     isFullyPaid: isFullyPaid(innerDeps),
     getTotalPrice: getTotalPrice(innerDeps),
     removePaymentModifiers: removePaymentModifiers(innerDeps),
     getItems: getItems(innerDeps),
+    getAmounts: getAmounts(innerDeps),
+    hasPaymentMethodType: hasPaymentMethodType(innerDeps),
+    removePaymentModifiersByPaymentId:
+      removePaymentModifiersByPaymentId(innerDeps),
+    hasPaymentModifierWithPaymentId: hasPaymentModifierWithPaymentId(innerDeps),
+    getBalance: getBalance(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/removePaymentModifiersByPaymentId.js

@@ -0,0 +1,13 @@
+module.exports = ({ modifierActions }) =>
+  function removePaymentModifiersByPaymentId({ item, paymentId }) {
+    if (!item || !Array.isArray(item.modifiers) || !paymentId) return item;
+
+    return {
+      ...item,
+      modifiers: item.modifiers.filter(
+        modifier =>
+          !modifierActions.getProperty(modifier, 'paymentId') ||
+          modifierActions.getProperty(modifier, 'paymentId') !== paymentId
+      ),
+    };
+  };

package/lib/modifier/areConditionsMet.js

@@ -1,7 +1,7 @@
 module.exports = ({ actions }) => {
   const modifierConditionPass = (
     modifier,
-    { item, paymentMethod, startRequestDate, endRequestDate }
+    { item, startRequestDate, endRequestDate }
   ) =>
     modifier.conditions && Array.isArray(modifier.conditions.rules)
       ? modifier.conditions.rules.every(condition => {
@@ -32,17 +32,9 @@ module.exports = ({ actions }) => {
                 condition.operand
               );
             case 'paymentMethods':
-              return actions.validateInArr(
-                paymentMethod ? paymentMethod.key : null,
-                condition.value,
-                condition.operand
-              );
+              return false;
             case 'paymentTypes':
-              return actions.validateInArr(
-                paymentMethod ? paymentMethod.type : null,
-                condition.value,
-                condition.operand
-              );
+              return false;
             default:
               return false;
           }
@@ -52,7 +44,6 @@ module.exports = ({ actions }) => {
   function areConditionsMet(modifier, opts) {
     const {
       item = null,
-      paymentMethod = null,
       endRequestDate = null,
       startRequestDate = null,
     } = opts;
@@ -61,7 +52,6 @@ module.exports = ({ actions }) => {
       modifier &&
       modifierConditionPass(modifier, {
         item,
-        paymentMethod,
         startRequestDate,
         endRequestDate,
       })

package/lib/modifier/calculatePaymentDiscountModifier.js

@@ -0,0 +1,31 @@
+module.exports = ({ utils, actions, constants }) => {
+  const { math } = utils;
+
+  return function calculatePaymentDiscountModifier({
+    paymentModifier,
+    amountToPay,
+  }) {
+    let amount = 0;
+
+    if (actions.isFixed(paymentModifier)) {
+      amount = paymentModifier.compute.amount;
+    }
+
+    if (actions.isPercentage(paymentModifier)) {
+      const discountAmount = math.div(paymentModifier.compute.amount, 100);
+
+      amount = math.sub(
+        math.div(amountToPay, math.sub(1, discountAmount)),
+        amountToPay
+      );
+    }
+
+    return actions.createDiscountModifier({
+      amount,
+      type: constants.Modifier.Compute.Types.FIXED,
+      modifierId: paymentModifier.modifierId,
+      _id: paymentModifier._id,
+      properties: paymentModifier.properties,
+    });
+  };
+};

package/lib/modifier/calculatePaymentFeeModifier.js

@@ -0,0 +1,27 @@
+module.exports = ({ utils, actions, constants }) => {
+  const { math } = utils;
+
+  return function calculatePaymentDiscountModifier({
+    paymentModifier,
+    amountToPay,
+  }) {
+    let amount = 0;
+
+    if (actions.isFixed(paymentModifier)) {
+      amount = paymentModifier.compute.amount;
+    }
+
+    if (actions.isPercentage(paymentModifier)) {
+      const feeAmount = math.div(paymentModifier.compute.amount, 100);
+      amount = math.mul(amountToPay, feeAmount);
+    }
+
+    return actions.createFeeModifier({
+      amount,
+      type: constants.Modifier.Compute.Types.FIXED,
+      modifierId: paymentModifier.modifierId,
+      _id: paymentModifier._id,
+      properties: paymentModifier.properties,
+    });
+  };
+};

package/lib/modifier/calculatePaymentModifier.js

@@ -0,0 +1,67 @@
+module.exports = ({ actions, utils }) => {
+  const { math } = utils;
+
+  return function calculatePaymentFeeModifier({
+    paymentModifier: paymentModifierParam,
+    amountToPay: amountToPayParam,
+    itemBalance: itemBalanceParam,
+    paymentMethod,
+    paymentType,
+    paymentId,
+  }) {
+    if (
+      !actions.hasPaymentMethodType({
+        paymentModifier: paymentModifierParam,
+        paymentMethod,
+        paymentType,
+      })
+    )
+      return undefined;
+
+    const paymentModifier = {
+      ...paymentModifierParam,
+      properties: {
+        ...(paymentModifierParam.properties || {}),
+        isCalculatedPaymentModifier: true,
+        paymentId,
+      },
+    };
+
+    const itemBalance =
+      typeof itemBalanceParam === 'number' ? itemBalanceParam : 0;
+
+    const calculatedPaymentMod = actions.calculate(paymentModifier, {
+      price: itemBalance,
+      quantity: 1,
+    });
+
+    const balanceIncludingPaymentModifier = math.add(
+      itemBalance,
+      calculatedPaymentMod._computed.amount
+    );
+
+    let amountToPay =
+      typeof amountToPayParam === 'number' ? amountToPayParam : 0;
+
+    amountToPay =
+      amountToPay && amountToPay < balanceIncludingPaymentModifier
+        ? amountToPay
+        : balanceIncludingPaymentModifier;
+
+    if (actions.isDiscount(paymentModifier)) {
+      return actions.calculatePaymentDiscountModifier({
+        amountToPay,
+        paymentModifier,
+      });
+    }
+
+    if (actions.isAdd(paymentModifier)) {
+      return actions.calculatePaymentFeeModifier({
+        amountToPay,
+        paymentModifier,
+      });
+    }
+
+    return undefined;
+  };
+};

package/lib/modifier/createDiscountModifier.js

@@ -2,7 +2,7 @@ module.exports = ({ constants, actions, localization }) => {
   const { Modifier } = constants;
 
   return function createDiscountModifier(params) {
-    const { amount, type, properties } = params;
+    const { amount, type, properties, ...rest } = params;
     const { formatAmount } = localization;
 
     const name =
@@ -21,6 +21,7 @@ module.exports = ({ constants, actions, localization }) => {
       properties: {
         ...properties,
       },
+      ...rest,
     });
   };
 };

package/lib/modifier/createFeeModifier.js

@@ -2,7 +2,7 @@ module.exports = ({ constants, actions, localization }) => {
   const { Modifier } = constants;
 
   return function createFeeModifier(params) {
-    const { amount, type, properties } = params;
+    const { amount, type, properties, ...rest } = params;
     const { formatAmount } = localization;
 
     const name =
@@ -22,6 +22,7 @@ module.exports = ({ constants, actions, localization }) => {
         ignoreQuantity: true,
         ...properties,
       },
+      ...rest,
     });
   };
 };

package/lib/modifier/getChildren.js

@@ -0,0 +1,8 @@
+module.exports = () =>
+  function getChildren({ parentModifier, modifiers }) {
+    if (!parentModifier || !Array.isArray(modifiers)) return [];
+
+    return modifiers.filter(
+      modifier => modifier._parentId === parentModifier._id
+    );
+  };

package/lib/modifier/getComputedAmount.js

@@ -0,0 +1,9 @@
+module.exports = ({ utils }) =>
+  function getComputedAmount({ modifiers }) {
+    if (!Array.isArray(modifiers)) return 0;
+
+    return modifiers.reduce(
+      (prevVal, currVal) => utils.math.add(prevVal, currVal._computed.amount),
+      0
+    );
+  };

package/lib/modifier/hasPaymentMethodType.js

@@ -0,0 +1,14 @@
+module.exports = ({ actions }) =>
+  function hasPaymentMethodType({
+    paymentModifier,
+    paymentMethod,
+    paymentType,
+  }) {
+    return (
+      actions.isPaymentModifier(paymentModifier) &&
+      paymentModifier.conditions.rules.some(
+        rule =>
+          rule.value.includes(paymentMethod) || rule.value.includes(paymentType)
+      )
+    );
+  };

package/lib/modifier/index.js

@@ -117,7 +117,6 @@ const isCredit = require('./isCredit');
 const purifyModifiers = require('./purifyModifiers');
 const sort = require('./sort');
 const isPaymentModifier = require('./isPaymentModifier');
-const createPaymentModifier = require('./createPaymentModifier');
 const isSubtract = require('./isSubtract');
 const isFixed = require('./isFixed');
 const isFixedAdd = require('./isFixedAdd');
@@ -127,7 +126,6 @@ const mutateModifier = require('./mutateModifier');
 const isFixedDiscount = require('./isFixedDiscount');
 const removeLocked = require('./removeLocked');
 const hasItems = require('./hasItems');
-const getLockedModifiers = require('./getLockedModifiers');
 const getGroupedModifiers = require('./getGroupedModifiers');
 const getNotesToModifierTags = require('./getNotesToModifierTags');
 const isOptionsOverride = require('./isOptionsOverride');
@@ -137,6 +135,15 @@ const validateNumberCondition = require('./validateNumberCondition');
 const validateRequiredModifiers = require('./validateRequiredModifiers');
 const validateDateDaysDiff = require('./validateDateDaysDiff');
 const validateInArr = require('./validateInArr');
+const isPercentage = require('./isPercentage');
+const getChildren = require('./getChildren');
+const getComputedAmount = require('./getComputedAmount');
+const hasPaymentMethodType = require('./hasPaymentMethodType');
+const calculatePaymentModifier = require('./calculatePaymentModifier');
+const calculatePaymentDiscountModifier = require('./calculatePaymentDiscountModifier');
+const calculatePaymentFeeModifier = require('./calculatePaymentFeeModifier');
+const isCalculatedPaymentModifier = require('./isCalculatedPaymentModifier');
+const isChild = require('./isChild');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -265,13 +272,11 @@ const modifierActions = (deps = {}) => {
     purifyModifiers: purifyModifiers(innerDeps),
     sort: sort(innerDeps),
     isPaymentModifier: isPaymentModifier(innerDeps),
-    createPaymentModifier: createPaymentModifier(innerDeps),
     isSubtract: isSubtract(innerDeps),
     isFixed: isFixed(innerDeps),
     isFixedDiscount: isFixedDiscount(innerDeps),
     removeLocked: removeLocked(innerDeps),
     hasItems: hasItems(innerDeps),
-    getLockedModifiers: getLockedModifiers(innerDeps),
     isFixedAdd: isFixedAdd(innerDeps),
     isFee: isFee(innerDeps),
     isAdd: isAdd(innerDeps),
@@ -286,6 +291,16 @@ const modifierActions = (deps = {}) => {
     validateDateDaysDiff: validateDateDaysDiff(innerDeps),
     validateInArr: validateInArr(innerDeps),
     areConditionsMet: areConditionsMet(innerDeps),
+    isPercentage: isPercentage(innerDeps),
+    getChildren: getChildren(innerDeps),
+    getComputedAmount: getComputedAmount(innerDeps),
+    hasPaymentMethodType: hasPaymentMethodType(innerDeps),
+    calculatePaymentModifier: calculatePaymentModifier(innerDeps),
+    calculatePaymentDiscountModifier:
+      calculatePaymentDiscountModifier(innerDeps),
+    calculatePaymentFeeModifier: calculatePaymentFeeModifier(innerDeps),
+    isCalculatedPaymentModifier: isCalculatedPaymentModifier(innerDeps),
+    isChild: isChild(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isCalculatedPaymentModifier.js

@@ -0,0 +1,4 @@
+module.exports = ({ actions }) =>
+  function isCalculatedPaymentModifier(modifier) {
+    return !!actions.getProperty(modifier, 'isCalculatedPaymentModifier');
+  };

package/lib/modifier/isChild.js

@@ -0,0 +1,6 @@
+module.exports = () =>
+  function isChild({ parentModifier, modifier }) {
+    if (!parentModifier || !modifier) return false;
+
+    return modifier._parentId === parentModifier._id;
+  };

package/lib/modifier/isDiscount.js

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

package/lib/modifier/isFee.js

@@ -1,6 +1,9 @@
-module.exports = ({ constants }) => {
+module.exports = ({ constants, actions }) => {
   const { Modifier } = constants;
   return function isFee(modifier) {
-    return !!(modifier && modifier.type === Modifier.Types.FEE);
+    return !!(
+      modifier &&
+      (modifier.type === Modifier.Types.FEE || actions.isAdd(modifier))
+    );
   };
 };

package/lib/modifier/isPaymentMethodModifier.js

@@ -3,6 +3,9 @@ module.exports = () =>
     return !!(
       modifier &&
       modifier.conditions &&
-      modifier.conditions.some(condition => condition.key === 'paymentMethods')
+      Array.isArray(modifier.conditions.rules) &&
+      modifier.conditions.rules.some(
+        condition => condition.key === 'paymentMethods'
+      )
     );
   };

package/lib/modifier/isPaymentTypeModifier.js

@@ -3,6 +3,9 @@ module.exports = () =>
     return !!(
       modifier &&
       modifier.conditions &&
-      modifier.conditions.some(condition => condition.key === 'paymentTypes')
+      Array.isArray(modifier.conditions.rules) &&
+      modifier.conditions.rules.some(
+        condition => condition.key === 'paymentTypes'
+      )
     );
   };