@darkpos/pricing 1.0.150 → 1.0.152

package/__TEST__/invoice/refundInvoices.test.js

@@ -104,263 +104,3 @@ describe('computeRefundables', () => {
     expect(refundables).toEqual([0, 0]);
   });
 });
-
-describe('applyRefundToInvoices', () => {
-  const invoicesForOnePayment = [
-    {
-      _id: 'inv-1',
-      amount: 25,
-      paymentOrderItems: [overpaidInvoiceItem, partiallyPaidInvoiceItem],
-    },
-  ];
-
-  test('the refund invoice has the correct total amount and both item refunds', () => {
-    const refundInvoices = pricing.invoice.applyRefundToInvoices(
-      invoicesForOnePayment,
-      ordersById,
-      4
-    );
-    expect(refundInvoices).toHaveLength(1);
-    expect(refundInvoices[0].amount).toBe(-4);
-    expect(refundInvoices[0].paymentOrderItems).toHaveLength(2);
-    expect(refundInvoices[0].paymentOrderItems[0].amount).toBe(-4.2);
-    expect(refundInvoices[0].paymentOrderItems[1].amount).toBe(0.2);
-  });
-
-  test('the overpaid item is cleared to its exact total and marked as paid', () => {
-    const refundInvoices = pricing.invoice.applyRefundToInvoices(
-      invoicesForOnePayment,
-      ordersById,
-      4
-    );
-    expect(refundInvoices[0].paymentOrderItems[0].status.paid.value).toBe(true);
-  });
-
-  test('the underpaid item receives a credit that covers its remaining balance and is marked as paid', () => {
-    const refundInvoices = pricing.invoice.applyRefundToInvoices(
-      invoicesForOnePayment,
-      ordersById,
-      4
-    );
-    expect(refundInvoices[0].paymentOrderItems[1].status.paid.value).toBe(true);
-  });
-
-  test('returns an empty array when the refund amount is 0', () => {
-    const refundInvoices = pricing.invoice.applyRefundToInvoices(
-      invoicesForOnePayment,
-      ordersById,
-      0
-    );
-    expect(refundInvoices).toEqual([]);
-  });
-
-  test('skips invoices that are already refunded or have no positive balance', () => {
-    const invoicesIncludingAlreadyRefunded = [
-      {
-        _id: 'inv-already-refunded',
-        amount: -5,
-        paymentOrderItems: [overpaidInvoiceItem],
-      },
-      ...invoicesForOnePayment,
-    ];
-    const refundInvoices = pricing.invoice.applyRefundToInvoices(
-      invoicesIncludingAlreadyRefunded,
-      ordersById,
-      4
-    );
-    expect(refundInvoices).toHaveLength(1);
-    expect(refundInvoices[0]._id).toBe('inv-1');
-  });
-
-  test('distributes the refund across multiple invoices when the first is exhausted', () => {
-    const splitPaymentInvoices = [
-      {
-        _id: 'first-payment',
-        amount: 14.7,
-        paymentOrderItems: [overpaidInvoiceItem],
-      },
-      {
-        _id: 'second-payment',
-        amount: 10.3,
-        paymentOrderItems: [partiallyPaidInvoiceItem],
-      },
-    ];
-    // Refund 5: overpaid item covers 4.2, the remaining 0.8 comes from the second invoice
-    const refundInvoices = pricing.invoice.applyRefundToInvoices(
-      splitPaymentInvoices,
-      ordersById,
-      5
-    );
-    expect(refundInvoices).toHaveLength(2);
-    expect(refundInvoices[0].amount).toBe(-4.2);
-    expect(refundInvoices[1].amount).toBe(-0.8);
-  });
-});
-
-describe('applyRefundToInvoices — 5-item order with 3 items priced to 0', () => {
-  const ORDER_5_ID = 'order-5items';
-
-  // Items as they appear in the payment invoice (stale totals from payment time)
-  const shortsInvoiceItem = {
-    orderId: ORDER_5_ID,
-    orderItemId: 'shorts',
-    total: 6.3,
-    totalPaid: 6.3,
-    amount: 6.3,
-    status: { paid: { value: true } },
-  };
-  const jacket1InvoiceItem = {
-    orderId: ORDER_5_ID,
-    orderItemId: 'jacket-1',
-    total: 8.93,
-    totalPaid: 8.93,
-    amount: 8.93,
-    status: { paid: { value: true } },
-  };
-  const longJacketInvoiceItem = {
-    orderId: ORDER_5_ID,
-    orderItemId: 'long-jacket',
-    total: 12.6,
-    totalPaid: 12.6,
-    amount: 12.6,
-    status: { paid: { value: true } },
-  };
-  const jacket2InvoiceItem = {
-    orderId: ORDER_5_ID,
-    orderItemId: 'jacket-2',
-    total: 8.93,
-    totalPaid: 8.93,
-    amount: 8.93,
-    status: { paid: { value: true } },
-  };
-  const coatInvoiceItem = {
-    orderId: ORDER_5_ID,
-    orderItemId: 'coat',
-    total: 13.65,
-    totalPaid: 3.24,
-    amount: 3.24,
-    status: { paid: { value: false } },
-  };
-
-  // Live order state after Jacket×2 and Long Jacket prices changed to 0
-  const liveOrder5 = {
-    _id: ORDER_5_ID,
-    items: [
-      {
-        _id: 'shorts',
-        total: 6.3,
-        totalPaid: 6.3,
-        status: { paid: { value: true } },
-      },
-      {
-        _id: 'jacket-1',
-        total: 0,
-        totalPaid: 8.93,
-        status: { paid: { value: true } },
-      },
-      {
-        _id: 'long-jacket',
-        total: 0,
-        totalPaid: 12.6,
-        status: { paid: { value: true } },
-      },
-      {
-        _id: 'jacket-2',
-        total: 0,
-        totalPaid: 8.93,
-        status: { paid: { value: true } },
-      },
-      {
-        _id: 'coat',
-        total: 13.65,
-        totalPaid: 3.24,
-        status: { paid: { value: false } },
-      },
-    ],
-  };
-
-  const ordersById5 = { [ORDER_5_ID]: liveOrder5 };
-
-  const paymentInvoices5 = [
-    {
-      invoiceId: 'inv-5items',
-      amount: 40,
-      paymentOrderItems: [
-        shortsInvoiceItem,
-        jacket1InvoiceItem,
-        longJacketInvoiceItem,
-        jacket2InvoiceItem,
-        coatInvoiceItem,
-      ],
-    },
-  ];
-
-  test('correctly refunds 20.05 — clears the 3 zero-priced items and credits the remaining balance to coat', () => {
-    const refundInvoices = pricing.invoice.applyRefundToInvoices(
-      paymentInvoices5,
-      ordersById5,
-      20.05
-    );
-
-    expect(refundInvoices).toHaveLength(1);
-    expect(refundInvoices[0].amount).toBe(-20.05);
-    expect(refundInvoices[0].paymentOrderItems).toHaveLength(4); // shorts has 0 excess, skipped
-
-    const byItemId = Object.fromEntries(
-      refundInvoices[0].paymentOrderItems.map(item => [item.orderItemId, item])
-    );
-
-    expect(byItemId['jacket-1'].amount).toBe(-8.93);
-    expect(byItemId['jacket-1'].status.paid.value).toBe(true);
-
-    expect(byItemId['long-jacket'].amount).toBe(-12.6);
-    expect(byItemId['long-jacket'].status.paid.value).toBe(true);
-
-    expect(byItemId['jacket-2'].amount).toBe(-8.93);
-    expect(byItemId['jacket-2'].status.paid.value).toBe(true);
-
-    expect(byItemId.coat.amount).toBe(10.41);
-    expect(byItemId.coat.status.paid.value).toBe(true);
-  });
-});
-
-describe('buildItemRefund', () => {
-  const overpaidItemState = pricing.invoice.resolveItemState(
-    overpaidInvoiceItem,
-    ordersById
-  );
-  const underpaidItemState = pricing.invoice.resolveItemState(
-    partiallyPaidInvoiceItem,
-    ordersById
-  );
-
-  test('overpaid item: refunding its full excess results in a negative amount and paid = true', () => {
-    const itemRefund = pricing.invoice.buildItemRefund(overpaidItemState, 4.2);
-    expect(itemRefund.amount).toBe(-4.2);
-    expect(itemRefund.totalPaid).toBe(14.7); // pre-refund value preserved
-    expect(itemRefund.total).toBe(10.5);
-    expect(itemRefund.status.paid.value).toBe(true); // 14.7 - 4.2 = 10.5 >= 10.5
-  });
-
-  test('underpaid item: applying a credit results in a positive amount and paid = true', () => {
-    const itemRefund = pricing.invoice.buildItemRefund(
-      underpaidItemState,
-      -0.2
-    );
-    expect(itemRefund.amount).toBe(0.2); // positive = credit
-    expect(itemRefund.totalPaid).toBe(10.3);
-    expect(itemRefund.total).toBe(10.5);
-    expect(itemRefund.status.paid.value).toBe(true); // 10.3 - (-0.2) = 10.5 >= 10.5
-  });
-
-  test('paid stays false when the refund does not fully cover the remaining balance', () => {
-    const itemRefund = pricing.invoice.buildItemRefund(underpaidItemState, 2); // totalPaid drops to 8.3
-    expect(itemRefund.status.paid.value).toBe(false); // 8.3 < 10.5
-  });
-
-  test('preserves all other fields from the original invoice item', () => {
-    const itemRefund = pricing.invoice.buildItemRefund(overpaidItemState, 4.2);
-    expect(itemRefund.orderId).toBe(ORDER_ID);
-    expect(itemRefund.orderItemId).toBe(OVERPAID_ITEM_ID);
-  });
-});

package/__TEST__/order/order-payment-modifier.test.js

@@ -574,9 +574,11 @@ describe('Order actions', () => {
       lockPaymentModifiers: true,
     });
 
+    paidOrderWithCredit.totalPaid += 1.25;
     const orderBalanceWithCredit = pricingService.order.getOrdersBalance({
       orders: [paidOrderWithCredit],
     });
+
     const itemBalanceWithCredit = pricingService.item.getItemsBalance({
       items: paidOrderWithCredit.items,
     });

package/__TEST__/order/order.test.js

@@ -3818,7 +3818,7 @@ describe('Order actions', () => {
     const pricing = usePricing({
       store: { _settings: { order: { autoMarkAsPaid: false } } },
     });
-    const order = { items: [orderItem], status: {} };
+    const order = { items: [orderItem], status: {}, totalPaid: 30 };
     const newOrder = pricing.order.calculate(order);
 
     expect(newOrder).toHaveProperty('total', 25);

package/__TEST__/payment.test.js

@@ -6,6 +6,17 @@ const session = {
 };
 
 const pricingService = usePricing(session);
+const pricingServiceMethodLabel = usePricing({
+  store: {
+    _settings: {
+      _settings: {
+        payment: {
+          methods: mockStores[0]._settings.payment.methods,
+        },
+      },
+    },
+  },
+});
 
 describe('getMaxAmountToRefund tests', () => {
   test('Returns 0 when payment is undefined', () => {
@@ -49,3 +60,220 @@ describe('getMaxAmountToRefund tests', () => {
     expect(pricingService.payment.getMaxAmountToRefund({ payment })).toBe(50);
   });
 });
+
+describe('getRefundableOrderAmount tests', () => {
+  test('Returns paid amount not attached to current items', () => {
+    const order = {
+      _id: 'order-1',
+      totalPaid: 5,
+      items: [
+        {
+          _id: 'item-2',
+          name: 'Simple Item 2',
+          total: 5,
+          totalPaid: 0,
+          status: { paid: { value: false } },
+        },
+      ],
+    };
+
+    expect(pricingService.payment.getRefundableOrderAmount({ order })).toBe(5);
+  });
+
+  test('Returns only the excess from items that actually received payment', () => {
+    const order = {
+      _id: 'order-2',
+      totalPaid: 14.7,
+      items: [
+        {
+          _id: 'item-1',
+          name: 'Winter Coat',
+          total: 1.05,
+          totalPaid: 14.7,
+          status: { paid: { value: true } },
+        },
+        {
+          _id: 'item-2',
+          name: 'Coat',
+          total: 1.05,
+          totalPaid: 0,
+          status: { paid: { value: false } },
+        },
+      ],
+    };
+
+    expect(pricingService.payment.getRefundableOrderAmount({ order })).toBe(
+      13.65
+    );
+  });
+});
+
+describe('getoverPaidOrders tests', () => {
+  test('Collects refundable child orders from a mixed parent list', () => {
+    const orders = [
+      {
+        _id: 'parent-1',
+        isParent: true,
+        orders: [
+          {
+            _id: 'child-1',
+            totalPaid: 5,
+            items: [
+              {
+                _id: 'item-1',
+                total: 5,
+                totalPaid: 0,
+                status: { paid: { value: false } },
+              },
+            ],
+          },
+          {
+            _id: 'child-2',
+            totalPaid: 5,
+            items: [
+              {
+                _id: 'item-2',
+                total: 5,
+                totalPaid: 5,
+                status: { paid: { value: true } },
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    expect(pricingService.payment.getOverPaidOrders({ orders })).toEqual({
+      overPaidAmount: 5,
+      overPaidOrders: [
+        {
+          _id: 'child-1',
+          totalPaid: 5,
+          items: [
+            {
+              _id: 'item-1',
+              total: 5,
+              totalPaid: 0,
+              status: { paid: { value: false } },
+            },
+          ],
+          refundableAmount: 5,
+        },
+      ],
+    });
+  });
+
+  test('Ignores empty and non-refundable orders', () => {
+    const orders = [
+      null,
+      {
+        _id: 'order-1',
+        totalPaid: 5,
+        items: [
+          {
+            _id: 'item-1',
+            total: 5,
+            totalPaid: 5,
+            status: { paid: { value: true } },
+          },
+        ],
+      },
+      {
+        isParent: true,
+        orders: [
+          {
+            _id: 'child-1',
+            totalPaid: 1,
+            items: [
+              {
+                _id: 'item-2',
+                total: 1,
+                totalPaid: 1,
+                status: { paid: { value: true } },
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    expect(pricingService.payment.getOverPaidOrders({ orders })).toEqual({
+      overPaidAmount: 0,
+      overPaidOrders: [],
+    });
+  });
+});
+
+describe('getMethodLabel tests', () => {
+  test('Returns the configured label for the payment provider', () => {
+    expect(
+      pricingServiceMethodLabel.payment.getMethodLabel({
+        paymentProvider: 'cash',
+      })
+    ).toBe('Cash');
+  });
+
+  test('Returns empty string when the provider is missing', () => {
+    expect(
+      pricingServiceMethodLabel.payment.getMethodLabel({
+        paymentProvider: 'missing-provider',
+      })
+    ).toBe('');
+  });
+});
+
+describe('appendIfOverPaid tests', () => {
+  test('Appends the order with refundableAmount when the order is overpaid', () => {
+    const currentOrder = {
+      _id: 'order-1',
+      displayId: '101',
+      totalPaid: 5,
+      items: [
+        {
+          _id: 'item-2',
+          name: 'Simple Item 2',
+          total: 5,
+          totalPaid: 0,
+          status: { paid: { value: false } },
+        },
+      ],
+    };
+
+    expect(
+      pricingService.payment.appendIfOverPaid({
+        currentOrder,
+        overPaidOrders: [{ _id: 'existing-order', refundableAmount: 1 }],
+      })
+    ).toEqual([
+      { _id: 'existing-order', refundableAmount: 1 },
+      {
+        ...currentOrder,
+        refundableAmount: 5,
+      },
+    ]);
+  });
+
+  test('Leaves the collection unchanged when the order has no refundable amount', () => {
+    const overPaidOrders = [{ _id: 'existing-order', refundableAmount: 1 }];
+    const currentOrder = {
+      _id: 'order-3',
+      totalPaid: 5,
+      items: [
+        {
+          _id: 'item-1',
+          name: 'Simple Item 1',
+          total: 5,
+          totalPaid: 5,
+          status: { paid: { value: true } },
+        },
+      ],
+    };
+
+    expect(
+      pricingService.payment.appendIfOverPaid({
+        currentOrder,
+        overPaidOrders,
+      })
+    ).toEqual(overPaidOrders);
+  });
+});

package/lib/invoice/index.js

@@ -2,8 +2,6 @@ const getStatusByItems = require('./getStatusByItems');
 const getTotalByItems = require('./getTotalByItems');
 const resolveItemState = require('./resolveItemState');
 const computeRefundables = require('./computeRefundables');
-const buildItemRefund = require('./buildItemRefund');
-const applyRefundToInvoices = require('./applyRefundToInvoices');
 
 const invoiceActions = (deps = {}) => {
   const actions = {};
@@ -18,8 +16,6 @@ const invoiceActions = (deps = {}) => {
     getTotalByItems: getTotalByItems(innerDeps),
     resolveItemState: resolveItemState(innerDeps),
     computeRefundables: computeRefundables(innerDeps),
-    buildItemRefund: buildItemRefund(innerDeps),
-    applyRefundToInvoices: applyRefundToInvoices(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/index.js

@@ -84,7 +84,6 @@ const getAmountToPayById = require('./getAmountToPayById');
 const applyPayment = require('./applyPayment');
 const getBalanceForPaymentModifier = require('./getBalanceForPaymentModifier');
 const isOverpaid = require('./isOverpaid');
-const getOverpaidAmount = require('./getOverpaidAmount');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -182,7 +181,6 @@ const itemActions = (deps = {}) => {
     applyPayment: applyPayment(innerDeps),
     getBalanceForPaymentModifier: getBalanceForPaymentModifier(innerDeps),
     isOverpaid: isOverpaid(innerDeps),
-    getOverpaidAmount: getOverpaidAmount(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

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

@@ -1,7 +1,7 @@
-module.exports = ({ actions, modifierActions }) => {
+module.exports = ({ actions, modifierActions, _ }) => {
   const getRemaining = (subscriptions, orderId) => {
     const remaining = subscriptions.reduce((total, subscription) => {
-      const { usesLimit = 0, uses = 0, history = {} } = subscription;
+      const { usesLimit = 0, uses = 0, history = {} } = subscription.item || {};
       const orderHistory = history[orderId] || 0;
       return total + usesLimit + orderHistory - uses;
     }, 0);
@@ -37,8 +37,18 @@ module.exports = ({ actions, modifierActions }) => {
 
   const getSubscriptions = subscriptions =>
     subscriptions
-      .map(each => modifierActions.getSubscriptionItem(each))
-      .filter(Boolean);
+      .map(each => _.get(each, 'properties.subscription'))
+      .filter(Boolean)
+      .filter(each => {
+        const renewalType = _.get(each, 'item.renewalType');
+        const endDate = _.get(each, 'dateLimit.to');
+        const today = new Date();
+
+        if (renewalType === 'none' && endDate && new Date(endDate) < today)
+          return false;
+
+        return true;
+      });
 
   return function hasRemainingSubscription({ order, item }) {
     if (!order || !item || !item.itemId) return [false];
@@ -53,7 +63,9 @@ module.exports = ({ actions, modifierActions }) => {
     subscriptions = getSubscriptions(subscriptions);
 
     const isUnlimited = subscriptions.some(
-      each => !each.usesLimit || each.renewalType === 'limit_reached'
+      each =>
+        !_.get(each, 'item.usesLimit') ||
+        _.get(each, 'item.renewalType') === 'limit_reached'
     );
     if (isUnlimited) return [true];
 

package/lib/order/index.js

@@ -100,7 +100,6 @@ 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 orderActions = (deps = {}) => {
@@ -213,7 +212,6 @@ const orderActions = (deps = {}) => {
     getTaxes: getTaxes(innerDeps),
     getPickedStatus: getPickedStatus(innerDeps),
     calculateWithPayment: calculateWithPayment(innerDeps),
-    getOverpaidAmount: getOverpaidAmount(innerDeps),
     hasSerial: hasSerial(innerDeps),
   });
 

package/lib/payment/appendIfOverPaid.js

@@ -0,0 +1,17 @@
+module.exports = ({ actions }) =>
+  function appendIfOverPaid({ currentOrder, overPaidOrders = [] }) {
+    if (!currentOrder || !currentOrder._id) return overPaidOrders;
+
+    const refundableAmount = actions.getRefundableOrderAmount({
+      order: currentOrder,
+    });
+    if (refundableAmount <= 0) return overPaidOrders;
+
+    return [
+      ...overPaidOrders,
+      {
+        ...currentOrder,
+        refundableAmount,
+      },
+    ];
+  };

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,36 @@
+module.exports = ({ actions }) =>
+  function getOverPaidOrders({ orders = [] }) {
+    let overPaidOrders = [];
+    let overPaidAmount = 0;
+
+    const appendIfOverPaid = currentOrder => {
+      overPaidOrders = actions.appendIfOverPaid({
+        currentOrder,
+        overPaidOrders,
+      });
+    };
+
+    (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);
+    });
+
+    overPaidAmount = overPaidOrders.reduce(
+      (total, order) => total + Number(order.refundableAmount || 0),
+      0
+    );
+
+    return {
+      overPaidOrders,
+      overPaidAmount,
+    };
+  };

package/lib/payment/getRefundableOrderAmount.js

@@ -0,0 +1,34 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+
+  return function getRefundableOrderAmount({ order }) {
+    if (!order) return 0;
+
+    const items = Array.isArray(order.items) ? order.items : [];
+    const paidItems = items.filter(item => Number(item.totalPaid || 0) > 0);
+
+    const itemsTotalPaid = items.reduce(
+      (acc, item) => math.add(acc, Number(item.totalPaid || 0)),
+      0
+    );
+    const paidItemsTotalPaid = paidItems.reduce(
+      (acc, item) => math.add(acc, Number(item.totalPaid || 0)),
+      0
+    );
+    const paidItemsTotal = paidItems.reduce(
+      (acc, item) => math.add(acc, Number(item.total || 0)),
+      0
+    );
+
+    const orphanedPaidAmount = math.max(
+      math.sub(order.totalPaid || 0, itemsTotalPaid),
+      0
+    );
+    const refundablePaidItemsAmount = math.max(
+      math.sub(paidItemsTotalPaid, paidItemsTotal),
+      0
+    );
+
+    return math.add(orphanedPaidAmount, refundablePaidItemsAmount);
+  };
+};

package/lib/payment/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.150",
+  "version": "1.0.152",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -54,5 +54,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "5ba2aa85fa455644dfa228072d30f8a8560d161c"
+  "gitHead": "1dff1f50b45bf68bd10e8d8ef7fe18c2b37c751e"
 }

package/lib/invoice/applyRefundToInvoices.js

@@ -1,52 +0,0 @@
-module.exports = ({ utils, actions }) => {
-  const { math } = utils;
-
-  /**
-   * Distributes a refund amount across a set of payment invoices.
-   *
-   * For each invoice, it resolves the live state of each item, computes
-   * the refundable amounts (order-independent), and builds the refund entries.
-   *
-   * Returns an array of refund invoices ready to be persisted — each with a
-   * negative amount (the refund) and updated paymentOrderItems.
-   */
-  return function applyRefundToInvoices(
-    paymentInvoices,
-    ordersById,
-    totalToRefund
-  ) {
-    let remaining = totalToRefund;
-
-    return paymentInvoices
-      .filter(({ amount }) => amount > 0)
-      .map(({ amount, paymentOrderItems, ...rest }) => {
-        if (remaining <= 0) return null;
-
-        const itemStates = (paymentOrderItems || []).map(item =>
-          actions.resolveItemState(item, ordersById)
-        );
-        const refundables = actions.computeRefundables(itemStates, remaining);
-
-        let invoiceRefundAmount = 0;
-        const itemRefunds = itemStates
-          .map((state, i) => {
-            const refundable = refundables[i];
-            if (refundable === 0) return null;
-            invoiceRefundAmount = math.add(invoiceRefundAmount, refundable);
-            return actions.buildItemRefund(state, refundable);
-          })
-          .filter(Boolean);
-
-        remaining = math.sub(remaining, invoiceRefundAmount);
-
-        if (invoiceRefundAmount <= 0) return null;
-
-        return {
-          ...rest,
-          amount: -invoiceRefundAmount,
-          paymentOrderItems: itemRefunds,
-        };
-      })
-      .filter(Boolean);
-  };
-};

package/lib/invoice/buildItemRefund.js

@@ -1,23 +0,0 @@
-module.exports = ({ utils }) => {
-  const { math } = utils;
-
-  return function buildItemRefund(
-    { item, itemTotal, itemTotalPaid, currentStatus },
-    refundable
-  ) {
-    const nextTotalPaid = math.sub(itemTotalPaid, refundable);
-    return {
-      ...item,
-      total: itemTotal,
-      totalPaid: itemTotalPaid,
-      amount: -refundable,
-      status: {
-        ...currentStatus,
-        paid: {
-          ...((currentStatus && currentStatus.paid) || {}),
-          value: nextTotalPaid >= itemTotal,
-        },
-      },
-    };
-  };
-};

package/lib/item/getOverpaidAmount.js

@@ -1,7 +0,0 @@
-module.exports = ({ utils }) =>
-  function getOverpaidAmount({ item }) {
-    const total = Number(item.total || 0);
-    const totalPaid = Number(item.totalPaid || 0);
-
-    return utils.math.sub(totalPaid, total);
-  };

package/lib/order/getOverpaidAmount.js

@@ -1,13 +0,0 @@
-module.exports = ({ utils }) =>
-  function getOverPaidAmount({ order }) {
-    if (!order) return 0;
-
-    return (order.items || []).reduce((net, item) => {
-      const itemTotalPaid = Number(item.totalPaid || 0);
-      if (itemTotalPaid <= 0) return net;
-      return utils.math.add(
-        net,
-        utils.math.sub(itemTotalPaid, Number(item.total || 0))
-      );
-    }, 0);
-  };