@darkpos/pricing 1.0.151 → 1.0.153

package/lib/order/applyRefund.js

@@ -0,0 +1,125 @@
+module.exports = ({ utils, actions }) =>
+  function applyRefund(options, amountToProcess = 0) {
+    const optionsWithAmount = options;
+    let amount = Math.abs(amountToProcess || 0);
+    let refundedAmount = 0;
+
+    Object.keys(options).forEach(orderId => {
+      const order = options[orderId];
+      const { items } = order;
+      const itemIds = Object.keys(items);
+
+      itemIds.forEach(itemId => {
+        const item = items[itemId];
+
+        items[itemId] = {
+          ...item,
+          orderId,
+          amount: item.amount || 0,
+        };
+      });
+
+      itemIds.forEach(itemId => {
+        if (amount <= 0) return;
+
+        const item = items[itemId];
+        const overPaidAmount = utils.math.max(
+          utils.math.sub(item.totalPaid || 0, item.total || 0),
+          0
+        );
+        const { refunded, item: updatedItem } = actions.refundOrderItem({
+          item,
+          orderId,
+          amountToRefund: utils.math.min(amount, overPaidAmount),
+        });
+
+        if (!updatedItem) return;
+
+        refundedAmount = utils.math.add(refundedAmount, refunded);
+        items[itemId] = updatedItem;
+        amount = utils.math.sub(amount, refunded);
+      });
+
+      itemIds.forEach(itemId => {
+        if (amount <= 0) return;
+
+        const item = items[itemId];
+        const { refunded, item: updatedItem } = actions.refundOrderItem({
+          item,
+          orderId,
+          amountToRefund: amount,
+        });
+
+        if (!updatedItem) return;
+
+        refundedAmount = utils.math.add(refundedAmount, refunded);
+        items[itemId] = updatedItem;
+        amount = utils.math.sub(amount, refunded);
+      });
+
+      itemIds.forEach((itemId, index) => {
+        const item = items[itemId];
+        let excess = utils.math.max(
+          utils.math.sub(item.totalPaid || 0, item.total || 0),
+          0
+        );
+
+        if (excess <= 0) return;
+
+        for (
+          let nextIndex = index + 1;
+          nextIndex < itemIds.length;
+          nextIndex += 1
+        ) {
+          if (excess <= 0) break;
+
+          const nextItemId = itemIds[nextIndex];
+          const nextItem = items[nextItemId];
+          const capacity = utils.math.max(
+            utils.math.sub(nextItem.total || 0, nextItem.totalPaid || 0),
+            0
+          );
+          const amountToMove = utils.math.min(excess, capacity);
+
+          if (amountToMove > 0) {
+            items[itemId] = {
+              ...items[itemId],
+              amount: utils.math.sub(items[itemId].amount || 0, amountToMove),
+              totalPaid: utils.math.sub(
+                items[itemId].totalPaid || 0,
+                amountToMove
+              ),
+            };
+
+            items[nextItemId] = {
+              ...nextItem,
+              amount: utils.math.add(nextItem.amount || 0, amountToMove),
+              totalPaid: utils.math.add(nextItem.totalPaid || 0, amountToMove),
+            };
+
+            excess = utils.math.sub(excess, amountToMove);
+          }
+        }
+      });
+
+      itemIds.forEach(itemId => {
+        const item = items[itemId];
+
+        items[itemId] = {
+          ...item,
+          status: {
+            ...item.status,
+            paid: {
+              value: (item.totalPaid || 0) >= (item.total || 0),
+              date: new Date(),
+            },
+          },
+        };
+      });
+    });
+
+    return {
+      options: optionsWithAmount,
+      refundedAmount,
+    };
+  };

package/lib/order/calculate.js

@@ -203,7 +203,6 @@ module.exports = ({
         paid,
         order: picked && paid ? 'closed' : 'open',
       },
-      totalPaid,
       properties: {
         ...(order.properties || {}),
         pieceCount,

package/lib/order/getOverPaidAmount.js

@@ -0,0 +1,13 @@
+module.exports = ({ itemActions, utils }) =>
+  function getOverPaidAmount({ order }) {
+    if (!order) return 0;
+
+    const { total: itemsTotal } = itemActions.getItemsTotals(order.items || []);
+
+    const orderTotalPaid = order.totalPaid || 0;
+
+    if (orderTotalPaid > itemsTotal)
+      return utils.math.sub(orderTotalPaid, itemsTotal);
+
+    return 0;
+  };

package/lib/order/getTotalPaidToRedistribute.js

@@ -0,0 +1,41 @@
+module.exports = ({ itemActions, utils }) =>
+  function getTotalPaidToRedistribute({ orders = [] }) {
+    const redistributableOrders = [];
+    let redistributableAmount = 0;
+
+    const appendIfRedistributable = currentOrder => {
+      const itemsTotalPaid = itemActions.getItemsTotalPaid({
+        orderItems: currentOrder.items || [],
+      });
+
+      const amount = utils.math.max(
+        utils.math.sub(currentOrder.totalPaid || 0, itemsTotalPaid),
+        0
+      );
+
+      if (amount > 0) {
+        redistributableOrders.push({
+          ...currentOrder,
+          redistributableAmount: amount,
+        });
+        redistributableAmount = utils.math.add(redistributableAmount, amount);
+      }
+    };
+
+    (orders || []).forEach(order => {
+      if (!order || !order._id) return;
+      if (order.isParent) {
+        const childOrders = order.orders || [];
+        if (childOrders.length > 0) {
+          childOrders.forEach(appendIfRedistributable);
+          return;
+        }
+      }
+      appendIfRedistributable(order);
+    });
+
+    return {
+      redistributableOrders,
+      redistributableAmount,
+    };
+  };

package/lib/order/index.js

@@ -82,6 +82,7 @@ const createSubOrder = require('./createSubOrder');
 const manualSplit = require('./manualSplit');
 const manualSplitByQuantity = require('./manualSplitByQuantity');
 const applyPayment = require('./applyPayment');
+const applyRefund = require('./applyRefund');
 const getBalance = require('./getBalance');
 const getLastLocation = require('./getLastLocation');
 const getModifierRelations = require('./getModifierRelations');
@@ -100,8 +101,10 @@ const removeEmptyNotes = require('./removeEmptyNotes');
 const getTaxes = require('./getTaxes');
 const getPickedStatus = require('./getPickedStatus');
 const calculateWithPayment = require('./calculateWithPayment');
-const getOverpaidAmount = require('./getOverpaidAmount');
 const hasSerial = require('./hasSerial');
+const getOverPaidAmount = require('./getOverPaidAmount');
+const getTotalPaidToRedistribute = require('./getTotalPaidToRedistribute');
+const refundOrderItem = require('./refundOrderItem');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -195,6 +198,7 @@ const orderActions = (deps = {}) => {
     manualSplit: manualSplit(innerDeps),
     manualSplitByQuantity: manualSplitByQuantity(innerDeps),
     applyPayment: applyPayment(innerDeps),
+    applyRefund: applyRefund(innerDeps),
     getOrdersBalance: getOrdersBalance(innerDeps),
     getLastLocation: getLastLocation(innerDeps),
     getModifierRelations: getModifierRelations(innerDeps),
@@ -213,8 +217,10 @@ const orderActions = (deps = {}) => {
     getTaxes: getTaxes(innerDeps),
     getPickedStatus: getPickedStatus(innerDeps),
     calculateWithPayment: calculateWithPayment(innerDeps),
-    getOverpaidAmount: getOverpaidAmount(innerDeps),
     hasSerial: hasSerial(innerDeps),
+    getOverPaidAmount: getOverPaidAmount(innerDeps),
+    getTotalPaidToRedistribute: getTotalPaidToRedistribute(innerDeps),
+    refundOrderItem: refundOrderItem(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/refundOrderItem.js

@@ -0,0 +1,29 @@
+module.exports = ({ utils }) =>
+  function refundOrderItem({ item, orderId, amountToRefund = 0 }) {
+    if (amountToRefund <= 0) return { refunded: 0 };
+
+    const refundableAmount = item.totalPaid || 0;
+    const refunded = utils.math.min(amountToRefund, refundableAmount);
+    const amountToAssign = utils.math.sub(0, refunded);
+    const updatedTotalPaid = utils.math.add(
+      item.totalPaid || 0,
+      amountToAssign
+    );
+
+    return {
+      refunded,
+      item: {
+        ...item,
+        orderId,
+        amount: utils.math.add(item.amount || 0, amountToAssign),
+        totalPaid: updatedTotalPaid,
+        status: {
+          ...item.status,
+          paid: {
+            value: updatedTotalPaid >= (item.total || 0),
+            date: new Date(),
+          },
+        },
+      },
+    };
+  };

package/lib/payment/getMethodLabel.js

@@ -0,0 +1,7 @@
+module.exports = ({ settings, _ }) =>
+  function getMethodLabel({ paymentProvider }) {
+    const methods = _.get(settings, '_settings.payment.methods', {});
+
+    if (!paymentProvider || !methods[paymentProvider]) return '';
+    return methods[paymentProvider].label || '';
+  };

package/lib/payment/getOverPaidOrders.js

@@ -0,0 +1,38 @@
+module.exports = ({ orderActions, utils }) =>
+  function getOverPaidOrders({ orders = [] }) {
+    const overPaidOrders = [];
+    let overPaidAmount = 0;
+
+    const appendIfOverPaid = currentOrder => {
+      const overPaidTotal = orderActions.getOverPaidAmount({
+        order: currentOrder,
+      });
+
+      if (overPaidTotal > 0) {
+        overPaidOrders.push({
+          ...currentOrder,
+          refundableAmount: overPaidTotal,
+        });
+        overPaidAmount = utils.math.add(overPaidAmount, overPaidTotal);
+      }
+    };
+
+    (orders || []).forEach(order => {
+      if (!order || !order._id) return;
+      if (order.isParent) {
+        const childOrders = order.orders || [];
+
+        if (childOrders.length > 0) {
+          childOrders.forEach(appendIfOverPaid);
+          return;
+        }
+      }
+
+      appendIfOverPaid(order);
+    });
+
+    return {
+      overPaidOrders,
+      overPaidAmount,
+    };
+  };

package/lib/payment/getRefundableOrderAmount.js

@@ -0,0 +1,21 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+
+  return function getRefundableOrderAmount({ order }) {
+    if (!order) return 0;
+
+    const items = Array.isArray(order.items) ? order.items : [];
+    const orderTotal =
+      typeof order.total === 'number'
+        ? order.total
+        : items.reduce(
+            (acc, item) => math.add(acc, Number(item.total || 0)),
+            0
+          );
+
+    return math.max(
+      math.sub(Number(order.totalPaid || 0), Number(orderTotal || 0)),
+      0
+    );
+  };
+};

package/lib/payment/index.js

@@ -1,5 +1,8 @@
 //
 const getMaxAmountToRefund = require('./getMaxAmountToRefund');
+const getRefundableOrderAmount = require('./getRefundableOrderAmount');
+const getMethodLabel = require('./getMethodLabel');
+const getOverPaidOrders = require('./getOverPaidOrders');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -11,6 +14,9 @@ const orderActions = (deps = {}) => {
 
   const freezedActions = Object.freeze({
     getMaxAmountToRefund: getMaxAmountToRefund(innerDeps),
+    getRefundableOrderAmount: getRefundableOrderAmount(innerDeps),
+    getMethodLabel: getMethodLabel(innerDeps),
+    getOverPaidOrders: getOverPaidOrders(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.151",
+  "version": "1.0.153",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -54,5 +54,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "f95dc7f14dcf4673e5fe25cb2faeb5eee26fb592"
+  "gitHead": "495fd0beca96603861fccf52ba2a5618fc632e7a"
 }