@darkpos/pricing 1.0.44 → 1.0.46

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/getInvalidRequiredModifiers.js

@@ -0,0 +1,24 @@
+module.exports = ({ modifierActions }) =>
+  function getInvalidRequiredModifiers({ item }) {
+    if (!item || !Array.isArray(item.modifiers)) return true;
+    const invalidModifiers = [];
+
+    item.modifiers.forEach(modifier => {
+      if (
+        modifierActions.isRequired(modifier) &&
+        modifierActions.isGroupOfModifiers(modifier) &&
+        !item.modifiers
+          .filter(mod => mod._id !== modifier._id)
+          .some(itemModifier =>
+            modifierActions.isRelatedModifier({
+              _id: itemModifier.modifierId || itemModifier._id,
+              modifier,
+            })
+          )
+      ) {
+        invalidModifiers.push(modifier);
+      }
+    });
+
+    return invalidModifiers;
+  };

package/lib/item/getItemModifiersDescription.js

@@ -10,7 +10,8 @@ module.exports = ({ modifierActions, _, settings }) =>
           modifierActions.isValid(each) &&
           !modifierActions.isAmountOverride(each) &&
           !modifierActions.isDepartment(each) &&
-          modifierActions.isDirect(each)
+          modifierActions.isDirect(each) &&
+          !modifierActions.isGroupOfModifiers(each)
       )
       .map(modifier => {
         const { name, _id, compute = {} } = modifier;

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/getPipeModifiers.js

@@ -0,0 +1,10 @@
+module.exports = ({ modifierActions }) =>
+  function getPipeModifiers({ item }) {
+    if (!item || !Array.isArray(item.modifiers)) return [];
+    return item.modifiers.filter(
+      modifier =>
+        modifierActions.isGroupOfModifiers(modifier) &&
+        modifierActions.isRequired(modifier) &&
+        modifierActions.enableAutoPopup(modifier)
+    );
+  };

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/hasModifier.js

@@ -1,15 +1,27 @@
-module.exports = () =>
+module.exports = ({ modifierActions }) =>
   function hasModifier({ item, modifier }) {
     if (!item || !modifier || !item.modifiers) return false;
 
-    const itemModifier = item.modifiers.find(
-      each =>
-        (each.modifierId &&
-          (each.modifierId === modifier.modifierId ||
-            each.modifierId === modifier._id)) ||
-        (typeof each.modifier === 'object' &&
-          each.modifier._id === modifier.modifierId)
-    );
+    if (modifierActions.isGroupOfModifiers(modifier)) {
+      const relatedModifiers = modifier.properties.group.modifiers;
+      return [
+        modifierActions.removeGroupData({ modifier }),
+        ...relatedModifiers,
+      ].some(relatedModifier =>
+        hasModifier({ item, modifier: relatedModifier })
+      );
+    }
+
+    const itemModifier = item.modifiers
+      .filter(itemMod => !modifierActions.isGroupOfModifiers(itemMod))
+      .find(
+        each =>
+          (each.modifierId &&
+            (each.modifierId === modifier.modifierId ||
+              each.modifierId === modifier._id)) ||
+          (typeof each.modifier === 'object' &&
+            each.modifier._id === modifier.modifierId)
+      );
 
     return !!itemModifier;
   };

package/lib/item/hasModifiers.js

@@ -1,9 +1,8 @@
-module.exports = () =>
+module.exports = ({ actions }) =>
   function hasModifiers({ item, modifiers }) {
     if (!item || !modifiers || !item.modifiers) return false;
 
-    return item.modifiers.some(
-      itemModifier =>
-        !!modifiers.find(each => each._id === itemModifier.modifierId)
+    return modifiers.some(each =>
+      actions.hasModifier({ item, modifier: each })
     );
   };

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

@@ -9,7 +9,6 @@ const removeModifiers = require('./removeModifiers');
 const findOriginalItem = require('./findOriginalItem');
 const create = require('./create');
 const hasModifier = require('./hasModifier');
-const isSelected = require('./isSelected');
 const hasModifiers = require('./hasModifiers');
 const addIndirectModifier = require('./addIndirectModifier');
 const calculate = require('./calculate');
@@ -20,10 +19,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 +29,18 @@ 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 getPipeModifiers = require('./getPipeModifiers');
+const getInvalidRequiredModifiers = require('./getInvalidRequiredModifiers');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -58,7 +62,6 @@ const itemActions = (deps = {}) => {
     findOriginalItem: findOriginalItem(innerDeps),
     create: create(innerDeps),
     hasModifier: hasModifier(innerDeps),
-    isSelected: isSelected(innerDeps),
     hasModifiers: hasModifiers(innerDeps),
     addIndirectModifier: addIndirectModifier(innerDeps),
     calculate: calculate(innerDeps),
@@ -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,19 @@ 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),
+    getPipeModifiers: getPipeModifiers(innerDeps),
+    getInvalidRequiredModifiers: getInvalidRequiredModifiers(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/duplicate.js

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

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/getGroupRelatedModifiers.js

@@ -19,7 +19,11 @@ module.exports = ({ actions }) => {
       return arr;
     }, []);
 
-    if (actions.includesInGroup(modifier)) groupModifiers.unshift(modifier);
+    if (actions.includesInGroup(modifier))
+      groupModifiers.unshift({
+        ...actions.removeGroupData({ modifier }),
+        required: false,
+      });
 
     return groupModifiers;
   };