@darkpos/pricing 1.0.92 → 1.0.95

package/lib/item/calculate.js

@@ -9,6 +9,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       typeof opts.amountToPay === 'number' ? opts.amountToPay : 0;
     const paymentMethod = opts.paymentMethod || null;
     const paymentType = opts.paymentType || null;
+    const isPrepay = opts.isPrepay || false;
     const startRequestDate = opts.startRequestDate || null;
     const endRequestDate = opts.endRequestDate || null;
     const lockPaymentModifiers = !!opts.lockPaymentModifiers;
@@ -27,8 +28,18 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       _actual: 0,
     };
 
+    if (actions.isOverwrittenPrice(item)) {
+      item.price = item.properties.overwrittenPrice;
+      item.properties.overwrittenPrice = undefined;
+    }
+
+    if (actions.isOverwrittenQuantity(item)) {
+      item.quantity = item.properties.overwrittenQuantity;
+      item.properties.overwrittenQuantity = undefined;
+    }
+
     const price = parseFloat(actions.getPriceWithoutModifiers({ item }));
-    const quantity = parseInt(item.quantity, 10);
+    let quantity = parseInt(item.quantity, 10);
     subTotals._simple = math.mul(price, quantity);
 
     const modifiers = [];
@@ -50,15 +61,11 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       })
     );
 
-    const amountOverride = validatedModifiers.find(each =>
-      modifierActions.isAmountOverride(each)
-    );
-
     const modifiersToCompute = validatedModifiers.filter(
       each =>
-        !modifierActions.isOverride(each) &&
-        each.compute &&
-        each.compute.type &&
+        ((each.compute && each.compute.type) ||
+          (modifierActions.isOverride(each) &&
+            !modifierActions.isNotesOverride(each))) &&
         modifierActions.isValid(each)
     );
 
@@ -70,6 +77,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
             paymentModifier: modifier,
             paymentMethod,
             paymentType,
+            isPrepay,
           })
       )
       .filter(paymentModifier => {
@@ -84,15 +92,14 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         );
       });
 
-    if (amountOverride) modifiersToCompute.push(amountOverride);
-
     const modifiersToNotCompute = validatedModifiers
       .filter(
         each =>
           modifierActions.isPaymentModifier(each) ||
           !modifiersToCompute.find(
             ceach => ceach.modifierId === each.modifierId
-          )
+          ) ||
+          modifierActions.isNotesOverride(each)
       )
       .map(each =>
         modifierActions.calculate(each, {
@@ -106,6 +113,18 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
     let computedPrice = price;
     let total = math.mul(computedPrice, quantity);
 
+    validatedModifiers.forEach(mod => {
+      if (
+        modifierActions.isNotesOverride(mod) &&
+        modifierActions.isValid(mod)
+      ) {
+        item.notes = actions.overrideNotes({
+          item,
+          message: modifierActions.getOverrideNote(mod),
+        }).notes;
+      }
+    });
+
     if (modifiersToCompute.length || paymentModifiersToCompute.length) {
       // sort modifiers based on sort
       const sortedModifiers = modifierActions.sort([
@@ -116,6 +135,8 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       let prvPrice = 0;
       let prvSort;
 
+      let accumulatedAmount = 0;
+
       for (const modifier of sortedModifiers) {
         const included = modifierActions.isIncluded(modifier);
         const direct = modifierActions.isDirect(modifier);
@@ -132,7 +153,10 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         if (modifierActions.isPaymentModifier(modifier)) {
           _modifier = modifierActions.calculatePaymentModifier({
             paymentModifier: modifier,
-            amountToPay,
+            amountToPay:
+              accumulatedAmount < 0 && amountToPay > 0
+                ? math.add(amountToPay, math.abs(accumulatedAmount))
+                : amountToPay,
             itemBalance:
               typeof item.totalPaid === 'number' && item.totalPaid > 0
                 ? actions.getItemsBalance({ items: [item] })
@@ -140,9 +164,36 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
             paymentMethod,
             paymentType,
             paymentId,
+            isPrepay,
           });
         }
 
+        if (modifierActions.isPriceOverride(modifier)) {
+          let priceOverride = modifierActions.getOverrideAmount(modifier);
+
+          if (modifierActions.isMultiplierOverride(modifier)) {
+            priceOverride = math.mul(priceOverride, price);
+          }
+
+          subTotals._simple = math.mul(priceOverride, quantity);
+          item.properties = {
+            ...(item.properties ? item.properties : {}),
+            overwrittenPrice: item.price,
+          };
+          item.price = priceOverride;
+        }
+
+        if (modifierActions.isQuantityOverride(modifier)) {
+          const newQuantity = modifierActions.getOverrideAmount(modifier);
+          item.properties = {
+            ...(item.properties ? item.properties : {}),
+            overwrittenQuantity: item.quantity,
+          };
+          subTotals._simple = math.mul(price, newQuantity);
+          item.quantity = parseInt(newQuantity, 10);
+          quantity = parseInt(newQuantity, 10);
+        }
+
         _modifier = modifierActions.calculate(
           { ..._modifier },
           {
@@ -168,15 +219,21 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
           computedAmount = _computed.amount;
 
         prvPrice = math.add(prvPrice, math.div(_computed.amount, quantity));
+        accumulatedAmount = math.add(accumulatedAmount, _computed.amount);
         prvSort = sort;
 
-        ({ subTotals, total } = actions.getTotals({
-          subTotals,
-          amountToAdd: computedAmount,
-          included,
-          type,
-          direct,
-        }));
+        if (
+          !modifierActions.isOverride(modifier) ||
+          modifierActions.isOverrideSubtotal(modifier)
+        ) {
+          ({ subTotals, total } = actions.getTotals({
+            subTotals,
+            amountToAdd: computedAmount,
+            included,
+            type,
+            direct,
+          }));
+        }
       }
     }
 

package/lib/item/getItemPrice.js

@@ -1,6 +1,4 @@
-module.exports = ({ modifierActions, utils }) => {
-  const { math } = utils;
-
+module.exports = ({ modifierActions }) => {
   const getCustomerTags = (customer = {}) =>
     ((customer && customer.tags) || []).filter(Boolean);
 
@@ -38,15 +36,6 @@ module.exports = ({ modifierActions, utils }) => {
 
     const { value } = maxPriceLevel;
 
-    const overridPriceModifier = modifiers.find(each =>
-      modifierActions.isPriceOverride(each)
-    );
-    if (overridPriceModifier && overridPriceModifier.compute) {
-      if (modifierActions.isMultiplier(overridPriceModifier))
-        return math.mul(value, overridPriceModifier.compute.amount);
-      return overridPriceModifier.compute.amount;
-    }
-
     return value;
   };
 };

package/lib/item/getPriceWithoutModifiers.js

@@ -1,21 +1,23 @@
-module.exports = ({ modifierActions }) =>
+module.exports = ({ actions, modifierActions }) =>
   /* eslint-disable no-restricted-syntax */
   function getPriceWithoutModifiers({ item }) {
+    const basePrice = actions.getBasePrice(item);
+
     if (
       !item ||
       !Array.isArray(item.modifiers) ||
-      typeof item.price !== 'number'
+      typeof basePrice !== 'number'
     )
-      return item.price;
+      return basePrice;
 
     const calculatedModifiers = item.modifiers.filter(modifier =>
       modifierActions.isExtractCalculatedValue({ modifier })
     );
 
-    if (calculatedModifiers.length === 0) return item.price;
+    if (calculatedModifiers.length === 0) return basePrice;
 
     const sortedModifiers = modifierActions.sort([...calculatedModifiers]);
-    let computedPrice = item.price;
+    let computedPrice = basePrice;
 
     for (const modifier of sortedModifiers) {
       computedPrice = modifierActions.getPriceWithoutModifier({

package/lib/item/hasPaymentMethodType.js

@@ -1,5 +1,10 @@
 module.exports = ({ modifierActions }) =>
-  function hasPaymentMethodType({ item, paymentMethod, paymentType }) {
+  function hasPaymentMethodType({
+    item,
+    paymentMethod,
+    paymentType,
+    isPrepay,
+  }) {
     if (
       !item ||
       !Array.isArray(item.modifiers) ||
@@ -12,6 +17,7 @@ module.exports = ({ modifierActions }) =>
         paymentModifier: modifier,
         paymentMethod,
         paymentType,
+        isPrepay,
       })
     );
   };

package/lib/item/index.js

@@ -63,6 +63,9 @@ const isSomeTagsMatch = require('./isSomeTagsMatch');
 const getTotals = require('./getTotals');
 const patchItem = require('./patchItem');
 const getUpdatedStatus = require('./getUpdatedStatus');
+const isOverwrittenPrice = require('./isOverwrittenPrice');
+const isOverwrittenQuantity = require('./isOverwrittenQuantity');
+const overrideNotes = require('./overrideNotes');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -139,6 +142,9 @@ const itemActions = (deps = {}) => {
     getTotals: getTotals(innerDeps),
     patchItem: patchItem(innerDeps),
     getUpdatedStatus: getUpdatedStatus(innerDeps),
+    isOverwrittenPrice: isOverwrittenPrice(innerDeps),
+    isOverwrittenQuantity: isOverwrittenQuantity(innerDeps),
+    overrideNotes: overrideNotes(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/isOverwrittenPrice.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isOverwrittenPrice(item) {
+    return item && item.properties && item.properties.overwrittenPrice;
+  };

package/lib/item/isOverwrittenQuantity.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isOverwrittenQuantity(item) {
+    return item && item.properties && item.properties.overwrittenQuantity;
+  };

package/lib/item/overrideNotes.js

@@ -0,0 +1,24 @@
+module.exports = ({ settings, _, moment, utils }) => {
+  const timezone = _.get(settings, 'localization.timezone', 'America/New_York');
+  const { helpers } = utils;
+
+  return function overrideNotes({ item, message }) {
+    if (!item) return undefined;
+
+    return {
+      ...item,
+      notes: [
+        {
+          _id: helpers.getObjectID(),
+          attributes: [],
+          date: moment().tz(timezone),
+          user: null,
+          message,
+          type: '',
+          name: 'override',
+          url: '',
+        },
+      ],
+    };
+  };
+};

package/lib/item/removeModifier.js

@@ -3,13 +3,7 @@ module.exports = ({ modifierActions, _, actions }) => {
     !!modifierActions.findById(itemModifiers, modifier._id) &&
     (!modifier.required || !modifier._parentId);
 
-  return function removeModifier({
-    item,
-    modifier,
-    customer,
-    originalItem,
-    order,
-  }) {
+  return function removeModifier({ item, modifier, order }) {
     const nextItem = _.cloneDeep(item);
     const itemModifiers = item.modifiers || [];
 
@@ -52,21 +46,6 @@ module.exports = ({ modifierActions, _, actions }) => {
         )
     );
 
-    const hasOverride = nextModifiers.find(each =>
-      modifierActions.isOverride(each)
-    );
-
-    if (hasOverride) {
-      if (modifierActions.isQuantityOverride(modifier)) nextItem.quantity = 1;
-
-      if (modifierActions.isPriceOverride(modifier))
-        nextItem.price = actions.getItemPrice({
-          item: originalItem,
-          itemPriceLevels: originalItem ? originalItem.priceLevels : undefined,
-          customer,
-        });
-    }
-
     return {
       ...nextItem,
       modifiers: nextModifiers,

package/lib/item/removeModifiers.js

@@ -1,11 +1,10 @@
 module.exports = ({ actions }) =>
-  function removeModifiers({ item, modifiers, originalItem, customer, order }) {
+  function removeModifiers({ item, modifiers, customer, order }) {
     const newItem = modifiers.reduce(
       (nextItem, modifier) =>
         actions.removeModifier({
           item: nextItem,
           modifier,
-          originalItem,
           customer,
           order,
         }),

package/lib/modifier/areConditionsMet.js

@@ -58,7 +58,7 @@ module.exports = ({ actions, utils }) => {
                 }
               }
               return actions.validateItemNumber(
-                itemSetIndex,
+                totalItemsLength,
                 conditionValue,
                 condition.operand
               );
@@ -92,6 +92,9 @@ module.exports = ({ actions, utils }) => {
               return false;
             case 'paymentTypes':
               return false;
+            case 'payment': {
+              return false;
+            }
             default:
               return false;
           }

package/lib/modifier/calculate.js

@@ -13,6 +13,15 @@ module.exports = ({ _, constants, utils, actions }) => {
   ) {
     const modifier = _modifier;
     const compute = getComputeModField(modifier);
+
+    if (actions.isOverride(_modifier)) {
+      if (actions.isAmountOverride(_modifier)) {
+        compute.type = 'fixed';
+        compute.action = 'add';
+      }
+      compute.amount = actions.getOverrideAmount(_modifier);
+    }
+
     const { type, amount: computeAmount = 0 } = compute;
     const _computed = {
       amount: 0,
@@ -55,7 +64,8 @@ module.exports = ({ _, constants, utils, actions }) => {
       if (
         (!actions.isOverride(_modifier) &&
           actions.isQuantityMultiplier(_modifier)) ||
-        (actions.isAmountOverride(_modifier) && actions.isMultiplier(_modifier))
+        (actions.isAmountOverride(_modifier) &&
+          actions.isMultiplierOverride(_modifier))
       ) {
         _computed.amount = math.mul(_computed.amount, options.quantity);
       }
@@ -68,6 +78,10 @@ module.exports = ({ _, constants, utils, actions }) => {
       ) {
         _computed.amount = math.mul(options.maxDiscountAmount, -1);
       }
+
+      if (actions.isTotalOverride(_modifier)) {
+        _computed.amount = math.sub(compute.amount, options.maxDiscountAmount);
+      }
     }
 
     _computed.description = actions.createDescription({
@@ -79,6 +93,10 @@ module.exports = ({ _, constants, utils, actions }) => {
       price: options.basePrice || options.price,
     });
 
-    return { ..._.cloneDeep(modifier), _computed };
+    return {
+      ..._.cloneDeep(modifier),
+      compute: compute.amount ? compute : null,
+      _computed,
+    };
   };
 };

package/lib/modifier/calculatePaymentModifier.js

@@ -8,12 +8,14 @@ module.exports = ({ actions, utils }) => {
     paymentMethod,
     paymentType,
     paymentId,
+    isPrepay,
   }) {
     if (
       !actions.hasPaymentMethodType({
         paymentModifier: paymentModifierParam,
         paymentMethod,
         paymentType,
+        isPrepay,
       })
     )
       return undefined;

package/lib/modifier/createDescription.js

@@ -10,7 +10,7 @@ module.exports = ({ actions, localization, _ }) =>
 
     const localBasePrice = localization.formatAmount(price || 0);
 
-    const isMultiplier = actions.isMultiplier(modifier);
+    const isMultiplier = actions.isMultiplierOverride(modifier);
 
     description = `${name}${localAmount ? ` (${localAmount})` : ''}`;
 

package/lib/modifier/duplicate.js

@@ -7,6 +7,9 @@ module.exports = ({ utils }) => {
       ...modifier,
       modifierId: modifier.modifierId || modifier._id,
       _id: helpers.getObjectID(),
+      compute: {
+        ...(modifier.compute || {}),
+      },
     };
   };
 };

package/lib/modifier/getOverrideAmount.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function getOverrideAmount(modifier) {
+    if (!actions.isOverride(modifier)) return 0;
+    const computeAmount = modifier.compute && modifier.compute.amount;
+    const { fixedValue } = modifier.properties.override;
+    return computeAmount || (typeof fixedValue === 'number' && fixedValue) || 0;
+  };

package/lib/modifier/getOverrideNote.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getOverrideNote(modifier) {
+    if (!actions.isOverride(modifier)) return '';
+    return modifier.properties.override.fixedValue;
+  };

package/lib/modifier/getServiceOverride.js

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

package/lib/modifier/hasPaymentMethodType.js

@@ -3,12 +3,27 @@ module.exports = ({ actions }) =>
     paymentModifier,
     paymentMethod,
     paymentType,
+    isPrepay,
   }) {
-    return (
-      actions.isPaymentModifier(paymentModifier) &&
-      paymentModifier.conditions.rules.some(
-        rule =>
-          rule.value.includes(paymentMethod) || rule.value.includes(paymentType)
+    if (!actions.isPaymentModifier(paymentModifier)) return false;
+
+    if (actions.isPrepayModifier(paymentModifier) && !isPrepay) return false;
+
+    if (
+      actions.isPaymentTypeModifier(paymentModifier) &&
+      !paymentModifier.conditions.rules.some(rule =>
+        rule.value.includes(paymentType)
       )
-    );
+    )
+      return false;
+
+    if (
+      actions.isPaymentMethodModifier(paymentModifier) &&
+      !paymentModifier.conditions.rules.some(rule =>
+        rule.value.includes(paymentMethod)
+      )
+    )
+      return false;
+
+    return true;
   };

package/lib/modifier/index.js

@@ -3,7 +3,6 @@ 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 createFeeModifier = require('./createFeeModifier');
@@ -48,7 +47,7 @@ const getRecommendedModifiers = require('./getRecommendedModifiers');
 const getRequiredModifiers = require('./getRequiredModifiers');
 const getSubscriptionItem = require('./getSubscriptionItem');
 const getSubscriptionModifiers = require('./getSubscriptionModifiers');
-const getService = require('./getService');
+const getServiceOverride = require('./getServiceOverride');
 const getSplittedModifiers = require('./getSplittedModifiers');
 const getSuggestion = require('./getSuggestion');
 const getUnhiddenModifiers = require('./getUnhiddenModifiers');
@@ -76,16 +75,16 @@ const isRemoveModifier = require('./isRemoveModifier');
 const isGroupOfModifiers = require('./isGroupOfModifiers');
 const areConditionsMet = require('./areConditionsMet');
 const isRequiredAndOverride = require('./isRequiredAndOverride');
-const isManual = require('./isManual');
+const isManualOverride = require('./isManualOverride');
 const isPriceOverride = require('./isPriceOverride');
 const isQuantityOverride = require('./isQuantityOverride');
-const isService = require('./isService');
+const isServiceOverride = require('./isServiceOverride');
 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 isMultiplierOverride = require('./isMultiplierOverride');
 const isAvailablePromotion = require('./isAvailablePromotion');
 const isAvailableSubscription = require('./isAvailableSubscription');
 const isPromotion = require('./isPromotion');
@@ -111,7 +110,6 @@ 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');
@@ -163,6 +161,12 @@ const isOrderUseValid = require('./isOrderUseValid');
 const getMaxItemQuantity = require('./getMaxItemQuantity');
 const createDescription = require('./createDescription');
 const patchModifier = require('./patchModifier');
+const isPrepayModifier = require('./isPrepayModifier');
+const isTotalOverride = require('./isTotalOverride');
+const getOverrideAmount = require('./getOverrideAmount');
+const getOverrideNote = require('./getOverrideNote');
+const isNotesOverride = require('./isNotesOverride');
+const isOverrideSubtotal = require('./isOverrideSubtotal');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -177,7 +181,6 @@ const modifierActions = (deps = {}) => {
     contains: contains(innerDeps),
     convertMenuModifiers: convertMenuModifiers(innerDeps),
     create: create(innerDeps),
-    createAmountOverrideModifier: createAmountOverrideModifier(innerDeps),
     createCreditModifier: createCreditModifier(innerDeps),
     createDiscountModifier: createDiscountModifier(innerDeps),
     createFeeModifier: createFeeModifier(innerDeps),
@@ -223,7 +226,7 @@ const modifierActions = (deps = {}) => {
     getRequiredModifiers: getRequiredModifiers(innerDeps),
     getSubscriptionItem: getSubscriptionItem(innerDeps),
     getSubscriptionModifiers: getSubscriptionModifiers(innerDeps),
-    getService: getService(innerDeps),
+    getServiceOverride: getServiceOverride(innerDeps),
     getSplittedModifiers: getSplittedModifiers(innerDeps),
     getSuggestion: getSuggestion(innerDeps),
     getUnhiddenModifiers: getUnhiddenModifiers(innerDeps),
@@ -248,8 +251,8 @@ const modifierActions = (deps = {}) => {
     isRemoveModifier: isRemoveModifier(innerDeps),
     isGroupOfModifiers: isGroupOfModifiers(innerDeps),
     isRequiredAndOverride: isRequiredAndOverride(innerDeps),
-    isManual: isManual(innerDeps),
-    isService: isService(innerDeps),
+    isManualOverride: isManualOverride(innerDeps),
+    isServiceOverride: isServiceOverride(innerDeps),
     isQuantityOverride: isQuantityOverride(innerDeps),
     isPriceOverride: isPriceOverride(innerDeps),
     isSingleValue: isSingleValue(innerDeps),
@@ -257,7 +260,7 @@ const modifierActions = (deps = {}) => {
     isOverride: isOverride(innerDeps),
     isDepartment: isDepartment(innerDeps),
     isRequired: isRequired(innerDeps),
-    isMultiplier: isMultiplier(innerDeps),
+    isMultiplierOverride: isMultiplierOverride(innerDeps),
     isAvailablePromotion: isAvailablePromotion(innerDeps),
     isAvailableSubscription: isAvailableSubscription(innerDeps),
     isPromotion: isPromotion(innerDeps),
@@ -286,7 +289,6 @@ const modifierActions = (deps = {}) => {
     isFixedAdd: isFixedAdd(innerDeps),
     isFee: isFee(innerDeps),
     isAdd: isAdd(innerDeps),
-    mutateModifier: mutateModifier(innerDeps),
     removeGroupData: removeGroupData(innerDeps),
     isRelatedModifierById: isRelatedModifierById(innerDeps),
     getGroupedModifiers: getGroupedModifiers(innerDeps),
@@ -339,6 +341,12 @@ const modifierActions = (deps = {}) => {
     getCreditModifiersTotalEntities: getCreditModifiersTotalEntities(innerDeps),
     createDescription: createDescription(innerDeps),
     patchModifier: patchModifier(innerDeps),
+    isPrepayModifier: isPrepayModifier(innerDeps),
+    isTotalOverride: isTotalOverride(innerDeps),
+    getOverrideAmount: getOverrideAmount(innerDeps),
+    getOverrideNote: getOverrideNote(innerDeps),
+    isNotesOverride: isNotesOverride(innerDeps),
+    isOverrideSubtotal: isOverrideSubtotal(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/{isManual.js → isManualOverride.js}

@@ -1,5 +1,5 @@
 module.exports = () =>
-  function isManual(modifier) {
+  function isManualOverride(modifier) {
     return !!(
       modifier &&
       modifier.properties &&

package/lib/modifier/{isMultiplier.js → isMultiplierOverride.js}

@@ -1,5 +1,5 @@
 module.exports = () =>
-  function isMultiplier(modifier) {
+  function isMultiplierOverride(modifier) {
     if (!modifier) return false;
     const _modifier = modifier.modifier || modifier;
     return !!(

package/lib/modifier/isNotesOverride.js

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

package/lib/modifier/isOverrideSubtotal.js

@@ -0,0 +1,9 @@
+module.exports = ({ actions }) =>
+  function isOverrideSubtotal(modifier) {
+    return (
+      actions.isOverride(modifier) &&
+      (actions.isAmountOverride(modifier) ||
+        actions.isOptionsOverride(modifier) ||
+        actions.isTotalOverride(modifier))
+    );
+  };