@darkpos/pricing 1.0.43 → 1.0.45

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

@@ -0,0 +1,61 @@
+module.exports = ({ actions }) => {
+  const modifierConditionPass = (
+    modifier,
+    { item, startRequestDate, endRequestDate }
+  ) =>
+    modifier.conditions && Array.isArray(modifier.conditions.rules)
+      ? modifier.conditions.rules.every(condition => {
+          switch (condition.key) {
+            case 'itemPieces':
+              return actions.validateNumberCondition(
+                item.pieces,
+                condition.value,
+                condition.operand
+              );
+            case 'itemQuantity':
+              return actions.validateNumberCondition(
+                item.quantity,
+                condition.value,
+                condition.operand
+              );
+            case 'modifiers':
+              return actions.validateRequiredModifiers(
+                item.modifiers,
+                condition.value,
+                condition.operand
+              );
+            case 'endDateDays':
+              return actions.validateDateDaysDiff(
+                startRequestDate,
+                endRequestDate,
+                condition.value,
+                condition.operand
+              );
+            case 'paymentMethods':
+              return false;
+            case 'paymentTypes':
+              return false;
+            default:
+              return false;
+          }
+        }) || modifier.locked
+      : true;
+
+  function areConditionsMet(modifier, opts) {
+    const {
+      item = null,
+      endRequestDate = null,
+      startRequestDate = null,
+    } = opts;
+    // const recommendedEndDate = storeActions.getRecommendedEndDate();
+    return (
+      modifier &&
+      modifierConditionPass(modifier, {
+        item,
+        startRequestDate,
+        endRequestDate,
+      })
+    );
+  }
+  return areConditionsMet;
+};

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

@@ -19,8 +19,6 @@ 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');
@@ -82,6 +80,7 @@ const isDirect = require('./isDirect');
 const hasNoTags = require('./hasNoTags');
 const isRemoveModifier = require('./isRemoveModifier');
 const isGroupOfModifiers = require('./isGroupOfModifiers');
+const areConditionsMet = require('./areConditionsMet');
 const isRequiredAndOverride = require('./isRequiredAndOverride');
 const isManual = require('./isManual');
 const isPriceOverride = require('./isPriceOverride');
@@ -102,6 +101,7 @@ const isDefault = require('./isDefault');
 const isIncluded = require('./isIncluded');
 const isCustomerTagsExtend = require('./isCustomerTagsExtend');
 const isAmountOverride = require('./isAmountOverride');
+const isValid = require('./isValid');
 const isDiscount = require('./isDiscount');
 const isHidden = require('./isHidden');
 const isIgnoreQuantity = require('./isIgnoreQuantity');
@@ -117,22 +117,33 @@ 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');
 const isFee = require('./isFee');
 const isAdd = require('./isAdd');
 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');
 const getGroupedModifierLabels = require('./getGroupedModifierLabels');
+const validate = require('./validate');
+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 = {};
@@ -163,8 +174,6 @@ const modifierActions = (deps = {}) => {
     enableAutoPopup: enableAutoPopup(innerDeps),
     filterByRequiredModifiers: filterByRequiredModifiers(innerDeps),
     findById: findById(innerDeps),
-    findByPaymentMethod: findByPaymentMethod(innerDeps),
-    findByPaymentType: findByPaymentType(innerDeps),
     getAvailablePromotions: getAvailablePromotions(innerDeps),
     getAvailablePromotionsOrSubscriptions:
       getAvailablePromotionsOrSubscriptions(innerDeps),
@@ -247,6 +256,7 @@ const modifierActions = (deps = {}) => {
     isDefault: isDefault(innerDeps),
     isCustomerTagsExtend: isCustomerTagsExtend(innerDeps),
     isAmountOverride: isAmountOverride(innerDeps),
+    isValid: isValid(innerDeps),
     isDiscount: isDiscount(innerDeps),
     isHidden: isHidden(innerDeps),
     isIgnoreQuantity: isIgnoreQuantity(innerDeps),
@@ -262,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),
@@ -277,6 +285,22 @@ const modifierActions = (deps = {}) => {
     getNotesToModifierTags: getNotesToModifierTags(innerDeps),
     isOptionsOverride: isOptionsOverride(innerDeps),
     getGroupedModifierLabels: getGroupedModifierLabels(innerDeps),
+    validate: validate(innerDeps),
+    validateNumberCondition: validateNumberCondition(innerDeps),
+    validateRequiredModifiers: validateRequiredModifiers(innerDeps),
+    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.paymentMethods || []).length > 0
+      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.paymentTypes || []).length > 0
+      Array.isArray(modifier.conditions.rules) &&
+      modifier.conditions.rules.some(
+        condition => condition.key === 'paymentTypes'
+      )
     );
   };

package/lib/modifier/isPercentage.js

@@ -0,0 +1,10 @@
+module.exports = ({ constants }) => {
+  const { Modifier } = constants;
+  return function isFixed(modifier) {
+    return !!(
+      modifier &&
+      modifier.compute &&
+      modifier.compute.type === Modifier.Compute.Types.PERCENTAGE
+    );
+  };
+};

package/lib/modifier/isValid.js

@@ -0,0 +1,12 @@
+module.exports = () =>
+  function isValid(modifier) {
+    if (
+      !modifier ||
+      !modifier.conditions ||
+      modifier.conditions.valid === undefined ||
+      modifier.conditions.valid === null
+    )
+      return true;
+
+    return !!modifier.conditions.valid;
+  };

package/lib/modifier/sort.js

@@ -6,6 +6,34 @@ module.exports = ({ actions }) => {
       const aVal = actions.getProperty(a, key);
       const bVal = actions.getProperty(b, key);
 
+      const aIsPaymentModifier = actions.isPaymentModifier(a);
+      const bIsPaymentModifier = actions.isPaymentModifier(b);
+      const aIsCalculatedPaymentModifier =
+        actions.isCalculatedPaymentModifier(a);
+      const bIsCalculatedPaymentModifier =
+        actions.isCalculatedPaymentModifier(b);
+
+      if (aIsCalculatedPaymentModifier && bIsPaymentModifier && aVal === null) {
+        return -1;
+      }
+      if (bIsCalculatedPaymentModifier && aIsPaymentModifier && bVal === null) {
+        return -1;
+      }
+
+      if (
+        (aIsPaymentModifier || aIsCalculatedPaymentModifier) &&
+        aVal === null
+      ) {
+        return 1;
+      }
+
+      if (
+        (bIsPaymentModifier || bIsCalculatedPaymentModifier) &&
+        bVal === null
+      ) {
+        return 1;
+      }
+
       if (aVal == null && bVal === null) {
         return 0;
       }

package/lib/modifier/validate.js

@@ -0,0 +1,14 @@
+module.exports = ({ actions }) => {
+  function validate(modifier, opts) {
+    if (!modifier) return modifier;
+
+    return {
+      ...modifier,
+      conditions: {
+        ...(modifier.conditions || {}),
+        valid: !!actions.areConditionsMet(modifier, opts),
+      },
+    };
+  }
+  return validate;
+};

package/lib/modifier/validateDateDaysDiff.js

@@ -0,0 +1,30 @@
+module.exports = () =>
+  function validateDateDaysDiff(
+    startRequestDate,
+    endRequestDate,
+    conditionNumber,
+    operand
+  ) {
+    if (!conditionNumber && !operand) return true;
+    if (!startRequestDate || !endRequestDate) return false;
+    const diff = Math.abs(
+      new Date(endRequestDate) - new Date(startRequestDate)
+    );
+    const diffDays = Math.ceil(diff / (1000 * 60 * 60 * 24));
+    switch (operand) {
+      case '$eq':
+        return diffDays === conditionNumber;
+      case '$ne':
+        return diffDays !== conditionNumber;
+      case '$gt':
+        return diffDays > conditionNumber;
+      case '$gte':
+        return diffDays >= conditionNumber;
+      case '$lt':
+        return diffDays < conditionNumber;
+      case '$lte':
+        return diffDays <= conditionNumber;
+      default:
+        return false;
+    }
+  };

package/lib/modifier/validateInArr.js

@@ -0,0 +1,12 @@
+module.exports = ({ _ }) =>
+  function validateInArr(item, requiredArr, operand) {
+    if (_.isEmpty(requiredArr) && !operand) return true;
+    switch (operand) {
+      case '$in':
+        return requiredArr.some(each => item === each);
+      case '$nin':
+        return requiredArr.every(each => item !== each);
+      default:
+        return false;
+    }
+  };

package/lib/modifier/validateNumberCondition.js

@@ -0,0 +1,20 @@
+module.exports = () =>
+  function validateNumberCondition(itemNumber, conditionNumber, operand) {
+    if (!conditionNumber && !operand) return true;
+    switch (operand) {
+      case '$eq':
+        return Number(conditionNumber) === itemNumber;
+      case '$ne':
+        return Number(conditionNumber) !== itemNumber;
+      case '$gt':
+        return Number(conditionNumber) < itemNumber;
+      case '$gte':
+        return Number(conditionNumber) <= itemNumber;
+      case '$lt':
+        return Number(conditionNumber) > itemNumber;
+      case '$lte':
+        return Number(conditionNumber) >= itemNumber;
+      default:
+        return false;
+    }
+  };