@darkpos/pricing 1.0.145 → 1.0.147

package/__TEST__/invoice/refundInvoices.test.js

@@ -0,0 +1,239 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+
+const pricing = usePricing({ store: mockStores[0] });
+
+const ORDER_ID = 'order-1';
+const OVERPAID_ITEM_ID = 'item-0';
+const UNDERPAID_ITEM_ID = 'item-1';
+
+const liveOrder = {
+  _id: ORDER_ID,
+  items: [
+    {
+      _id: OVERPAID_ITEM_ID,
+      total: 10.5,
+      totalPaid: 14.7,
+      status: { paid: { value: true }, picked: { value: false } },
+    },
+    {
+      _id: UNDERPAID_ITEM_ID,
+      total: 10.5,
+      totalPaid: 10.3,
+      status: { paid: { value: false }, picked: { value: false } },
+    },
+  ],
+};
+
+const ordersById = { [ORDER_ID]: liveOrder };
+
+const overpaidInvoiceItem = {
+  orderId: ORDER_ID,
+  orderItemId: OVERPAID_ITEM_ID,
+  total: 14.7,
+  totalPaid: 14.7,
+  amount: 14.7,
+  status: { paid: { value: true }, picked: { value: false } },
+};
+
+const partiallyPaidInvoiceItem = {
+  orderId: ORDER_ID,
+  orderItemId: UNDERPAID_ITEM_ID,
+  total: 13.65,
+  totalPaid: 10.3,
+  amount: 10.3,
+  status: { paid: { value: false }, picked: { value: false } },
+};
+
+describe('computeRefundables', () => {
+  const overpaidState = pricing.invoice.resolveItemState(
+    overpaidInvoiceItem,
+    ordersById
+  ); // excess +4.2
+  const underpaidState = pricing.invoice.resolveItemState(
+    partiallyPaidInvoiceItem,
+    ordersById
+  ); // excess -0.2
+
+  test('refunds the full excess from the overpaid item and redistributes the surplus to the underpaid item', () => {
+    const [overpaidRefundable, underpaidCredit] =
+      pricing.invoice.computeRefundables([overpaidState, underpaidState], 4);
+    expect(overpaidRefundable).toBe(4.2); // full overpayment cleared
+    expect(underpaidCredit).toBe(-0.2); // 0.2 credit applied to cover the gap
+  });
+
+  test('net refund amount across all items equals the requested refund total', () => {
+    const [overpaidRefundable, underpaidCredit] =
+      pricing.invoice.computeRefundables([overpaidState, underpaidState], 4);
+    expect(overpaidRefundable + underpaidCredit).toBe(4);
+  });
+
+  test('result is order-independent — same outcome when items are reversed', () => {
+    const [underpaidCredit, overpaidRefundable] =
+      pricing.invoice.computeRefundables([underpaidState, overpaidState], 4);
+    expect(overpaidRefundable).toBe(4.2);
+    expect(underpaidCredit).toBe(-0.2);
+  });
+
+  test('never-paid item receives no credit even when overpaid surplus exists', () => {
+    const neverPaidState = {
+      ...pricing.invoice.resolveItemState(partiallyPaidInvoiceItem, ordersById),
+      itemTotalPaid: 0,
+      excess: -10.5,
+    };
+    const [overpaidRefundable, neverPaidRefundable] =
+      pricing.invoice.computeRefundables([overpaidState, neverPaidState], 4);
+    expect(overpaidRefundable).toBe(4); // capped — no surplus to redistribute
+    expect(neverPaidRefundable).toBe(0); // never-paid item stays untouched
+  });
+
+  test('draws directly from totalPaid when no overpaid items exist', () => {
+    const exactlyPaidState = { ...overpaidState, excess: 0 };
+    const [refundable] = pricing.invoice.computeRefundables(
+      [exactlyPaidState],
+      5
+    );
+    expect(refundable).toBe(5);
+  });
+
+  test('returns all zeros when the requested refund amount is 0', () => {
+    const refundables = pricing.invoice.computeRefundables(
+      [overpaidState, underpaidState],
+      0
+    );
+    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('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/addItem.test.js

@@ -201,6 +201,75 @@ describe('addItem function', () => {
     expect(updatedOrder.items[0].modifiers).toHaveLength(2); // Added item should have modifiers
   });
 
+  test('should return original order when item serial is duplicated', () => {
+    const { addItem } = pricingService.order;
+
+    const order = {
+      items: [
+        {
+          _id: 'existing-item',
+          itemId: '111',
+          quantity: 1,
+          price: 100,
+          serial: 'ABC-123',
+          modifiers: [],
+        },
+      ],
+    };
+
+    const item = {
+      _id: 'new-item',
+      itemId: '222',
+      quantity: 1,
+      price: 50,
+      serial: ' abc-123 ',
+      modifiers: [],
+    };
+
+    const result = addItem({
+      order,
+      item,
+      itemIndex: -1,
+      overridenQuantity: -1,
+    });
+
+    expect(result).toBe(order);
+  });
+
+  test('should return original order when autoBarcode serial is duplicated', () => {
+    const { addItem } = pricingService.order;
+
+    const order = {
+      items: [
+        {
+          _id: 'existing-item',
+          itemId: '111',
+          quantity: 1,
+          price: 100,
+          serial: 'ABC-123',
+          modifiers: [],
+        },
+      ],
+    };
+
+    const item = {
+      _id: 'new-item',
+      itemId: '222',
+      quantity: 1,
+      price: 50,
+      modifiers: [],
+    };
+
+    const result = addItem({
+      order,
+      item,
+      itemIndex: 1,
+      autoBarcode: 'ABC-123',
+    });
+
+    expect(result).toBe(order);
+  });
+
   test('Add Related Item', () => {
     const { addItem } = pricingService.order;
 

package/__TEST__/order/pickEndDate.test.js

@@ -1,7 +1,7 @@
 const moment = require('moment-timezone');
 const usePricing = require('../../lib/index');
 
-const getDefaultSettings = schedules => ({
+const getDefaultSettings = (schedules, readyDateCapacityDays = []) => ({
   store: {
     _settings: {
       schedule: {
@@ -24,6 +24,9 @@ const getDefaultSettings = schedules => ({
             cutHour: null,
           },
         ],
+        readyDateCapacity: {
+          days: readyDateCapacityDays,
+        },
       },
     },
   },
@@ -115,7 +118,7 @@ describe('pickEndDate function', () => {
       recommended: 'nothing_recommended',
     };
 
-    const now = moment().tz('America/New_York');
+    const now = moment('2024-08-25T15:00:00Z').tz('America/New_York');
 
     jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
     const pricingServiceTest = usePricing(getDefaultSettings([schedule]));
@@ -299,4 +302,207 @@ describe('pickEndDate function', () => {
 
     expect(result).toBe('2025-05-15T22:00:00Z');
   });
+
+  test('pickEndDate - skips day when maxOrders capacity is reached', () => {
+    const schedule = {
+      addDays: 0,
+      readyHour: { hour: 17, minute: 0 },
+      skipDays: [],
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 1,
+    };
+
+    const pricingService = usePricing(
+      getDefaultSettings([schedule], [{ day: 2, maxOrders: 1 }])
+    );
+
+    const now = moment('2025-05-13T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingService.store.pickEndDate(
+      undefined,
+      undefined,
+      undefined,
+      [
+        {
+          date: '2025-05-13',
+          totalOrders: 1,
+          totalItems: 0,
+        },
+      ]
+    );
+
+    expect(result).toBe('2025-05-14T21:00:00Z');
+  });
+
+  test('pickEndDate - skips day when maxItems capacity is reached', () => {
+    const schedule = {
+      addDays: 0,
+      readyHour: { hour: 17, minute: 0 },
+      skipDays: [],
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 1,
+    };
+
+    const pricingService = usePricing(
+      getDefaultSettings([schedule], [{ day: 2, maxItems: 1 }])
+    );
+
+    const now = moment('2025-05-13T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingService.store.pickEndDate(
+      undefined,
+      undefined,
+      undefined,
+      [
+        {
+          date: '2025-05-13',
+          totalOrders: 0,
+          totalItems: 1,
+        },
+      ]
+    );
+
+    expect(result).toBe('2025-05-14T21:00:00Z');
+  });
+
+  test('pickEndDate - moves to next available day when capacity is full', () => {
+    const schedule = {
+      addDays: 2,
+      readyHour: { hour: 17, minute: 0 },
+      skipDays: [],
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 1,
+      dayOfWeek: [1, 2, 3, 4, 5],
+    };
+
+    const pricingService = usePricing(
+      getDefaultSettings([schedule], [{ day: 6, maxOrders: 1 }])
+    );
+
+    const now = moment('2026-02-26T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingService.store.pickEndDate(
+      undefined,
+      undefined,
+      undefined,
+      [
+        {
+          date: '2026-02-28',
+          totalOrders: 1,
+          totalItems: 0,
+        },
+      ]
+    );
+
+    expect(result).toBe('2026-03-01T22:00:00Z');
+  });
+
+  test('pickEndDate - skips closed day after capacity overflow', () => {
+    const schedule = {
+      addDays: 2,
+      readyHour: { hour: 17, minute: 0 },
+      skipDays: null,
+      cutHour: { hour: 10, minute: 0 },
+      cutDay: 1,
+    };
+
+    const pricingService = usePricing({
+      store: {
+        _settings: {
+          schedule: {
+            closed: [{ date: '2026-03-01' }],
+          },
+          order: {
+            schedules: [schedule],
+            readyDateCapacity: {
+              days: [
+                { day: 6, maxOrders: 2, maxItems: 10 },
+                { day: 1, maxOrders: 10, maxItems: 10 },
+              ],
+            },
+          },
+        },
+      },
+    });
+
+    const now = moment('2026-02-25T16:04:51Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingService.store.pickEndDate(
+      undefined,
+      undefined,
+      undefined,
+      [
+        { date: '2026-02-26', totalOrders: 4, totalItems: 5 },
+        { date: '2026-02-27', totalOrders: 1, totalItems: 1 },
+        { date: '2026-02-28', totalOrders: 2, totalItems: 2 },
+      ]
+    );
+
+    expect(result).toBe('2026-03-02T22:00:00Z');
+  });
+
+  test('pickEndDate - skips multiple consecutive capacity-full days', () => {
+    const schedule = {
+      addDays: 0,
+      readyHour: { hour: 17, minute: 0 },
+      skipDays: [],
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 1,
+    };
+
+    const pricingService = usePricing(
+      getDefaultSettings(
+        [schedule],
+        [
+          { day: 2, maxOrders: 1 },
+          { day: 3, maxOrders: 1 },
+        ]
+      )
+    );
+
+    const now = moment('2025-05-13T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingService.store.pickEndDate(
+      undefined,
+      undefined,
+      undefined,
+      [
+        { date: '2025-05-13', totalOrders: 1, totalItems: 0 },
+        { date: '2025-05-14', totalOrders: 1, totalItems: 0 },
+      ]
+    );
+
+    expect(result).toBe('2025-05-15T21:00:00Z');
+  });
+
+  test('pickEndDate - returns base date when no capacity counts are provided', () => {
+    const schedule = {
+      addDays: 0,
+      readyHour: { hour: 17, minute: 0 },
+      skipDays: [],
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 1,
+    };
+
+    const pricingService = usePricing(
+      getDefaultSettings([schedule], [{ day: 2, maxOrders: 1 }])
+    );
+
+    const now = moment('2025-05-13T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+
+    const result = pricingService.store.pickEndDate(
+      undefined,
+      undefined,
+      undefined,
+      []
+    );
+
+    expect(result).toBe('2025-05-13T21:00:00Z');
+  });
 });

package/lib/constants/Store.js

@@ -0,0 +1,3 @@
+module.exports = {
+  MAX_ADD_DAYS: 365,
+};

package/lib/constants/index.js

@@ -1,7 +1,9 @@
 const Status = require('./Status');
 const Modifier = require('./Modifier');
+const Store = require('./Store');
 
 module.exports = {
   Status,
   Modifier,
+  Store,
 };

package/lib/invoice/applyRefundToInvoices.js

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,23 @@
+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/invoice/computeRefundables.js

@@ -0,0 +1,59 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+
+  return function computeRefundables(itemStates, totalToRefund) {
+    const refundables = new Array(itemStates.length).fill(0);
+
+    if (totalToRefund <= 0) return refundables;
+
+    // Only partially-paid underpaid items are eligible to absorb redistribution credits.
+    const eligibleDeficit = itemStates.reduce(
+      (sum, { excess, itemTotalPaid }) => {
+        const isPartiallyPaidAndUnderpaid = excess < 0 && itemTotalPaid > 0;
+        return isPartiallyPaidAndUnderpaid
+          ? math.add(sum, math.sub(0, excess))
+          : sum;
+      },
+      0
+    );
+
+    // Cap total drawn from overpaid items so the net refund never exceeds totalToRefund.
+    let maxFromOverpaid = math.add(totalToRefund, eligibleDeficit);
+    let tempRemaining = totalToRefund;
+
+    // Pass 1: refund each overpaid item's excess, capped by maxFromOverpaid
+    itemStates.forEach(({ excess }, i) => {
+      if (excess > 0 && maxFromOverpaid > 0) {
+        const refund = excess > maxFromOverpaid ? maxFromOverpaid : excess;
+        refundables[i] = refund;
+        tempRemaining = math.sub(tempRemaining, refund);
+        maxFromOverpaid = math.sub(maxFromOverpaid, refund);
+      }
+    });
+
+    if (tempRemaining < 0) {
+      // Pass 2a: over-refunded — spread surplus as credits to partially-paid underpaid items
+      let surplus = math.sub(0, tempRemaining);
+      itemStates.forEach(({ excess, itemTotalPaid }, i) => {
+        if (excess < 0 && itemTotalPaid > 0 && surplus > 0) {
+          const deficit = math.sub(0, excess);
+          const credit = surplus > deficit ? deficit : surplus;
+          refundables[i] = -credit;
+          surplus = math.sub(surplus, credit);
+        }
+      });
+    } else if (tempRemaining > 0) {
+      // Pass 2b: under-refunded — draw remainder from non-overpaid items (totalPaid > 0)
+      itemStates.forEach(({ itemTotalPaid, excess }, i) => {
+        if (excess <= 0 && itemTotalPaid > 0 && tempRemaining > 0) {
+          const refund =
+            tempRemaining > itemTotalPaid ? itemTotalPaid : tempRemaining;
+          refundables[i] = refund;
+          tempRemaining = math.sub(tempRemaining, refund);
+        }
+      });
+    }
+
+    return refundables;
+  };
+};

package/lib/invoice/index.js

@@ -1,5 +1,9 @@
 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 = {};
@@ -12,6 +16,10 @@ const invoiceActions = (deps = {}) => {
   const freezedActions = Object.freeze({
     getStatusByItems: getStatusByItems(innerDeps),
     getTotalByItems: getTotalByItems(innerDeps),
+    resolveItemState: resolveItemState(innerDeps),
+    computeRefundables: computeRefundables(innerDeps),
+    buildItemRefund: buildItemRefund(innerDeps),
+    applyRefundToInvoices: applyRefundToInvoices(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/invoice/resolveItemState.js

@@ -0,0 +1,25 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+
+  return function resolveItemState(paymentOrderItem, ordersById) {
+    const order = (ordersById && ordersById[paymentOrderItem.orderId]) || {};
+    const orderItem = (order.items || []).find(
+      each => each._id === paymentOrderItem.orderItemId
+    );
+
+    const itemTotal =
+      (orderItem && orderItem.total) || paymentOrderItem.total || 0;
+    const itemTotalPaid =
+      (orderItem && orderItem.totalPaid) || paymentOrderItem.totalPaid || 0;
+    const currentStatus =
+      (orderItem && orderItem.status) || paymentOrderItem.status || {};
+
+    return {
+      item: paymentOrderItem,
+      itemTotal,
+      itemTotalPaid,
+      currentStatus,
+      excess: math.sub(itemTotalPaid, itemTotal),
+    };
+  };
+};

package/lib/order/addItem.js

@@ -227,6 +227,8 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       originalItem: item,
     });
 
+    if (actions.hasSerial({ order, item: orderItem })) return orderProp;
+
     const params = addOrderItem({
       order,
       item: orderItem,

package/lib/store/getClosedDays.js

@@ -0,0 +1,7 @@
+module.exports = ({ _, settings }) =>
+  function getClosedDays() {
+    const schedule = _.get(settings, 'schedule', {});
+    const { closed = [] } = schedule;
+    if (!Array.isArray(closed)) return [];
+    return closed;
+  };

package/lib/store/getReadyDateCapacityDays.js

@@ -0,0 +1,4 @@
+module.exports = ({ _, settings }) =>
+  function getReadyDateCapacityDays() {
+    return _.get(settings, 'order.readyDateCapacity.days', []);
+  };

package/lib/store/getReadyDateCountsByDate.js

@@ -0,0 +1,33 @@
+module.exports = ({ _, moment }) =>
+  function getReadyDateCountsByDate(counts = []) {
+    const countsByDate = new Map();
+
+    if (!Array.isArray(counts) || !counts.length) return countsByDate;
+
+    counts.forEach(dayCount => {
+      const rawDate = _.get(dayCount, 'date');
+      if (!rawDate) return;
+
+      const utcDateKey = moment.utc(rawDate).format('YYYY-MM-DD');
+      if (!utcDateKey || utcDateKey === 'Invalid date') return;
+
+      const currentValue = countsByDate.get(utcDateKey) || {
+        totalOrders: 0,
+        totalItems: 0,
+      };
+
+      const nextOrders = Number(_.get(dayCount, 'totalOrders'));
+      const nextItems = Number(_.get(dayCount, 'totalItems'));
+
+      countsByDate.set(utcDateKey, {
+        totalOrders:
+          currentValue.totalOrders +
+          (Number.isFinite(nextOrders) && nextOrders > 0 ? nextOrders : 0),
+        totalItems:
+          currentValue.totalItems +
+          (Number.isFinite(nextItems) && nextItems > 0 ? nextItems : 0),
+      });
+    });
+
+    return countsByDate;
+  };

package/lib/store/getSchedule.js

@@ -0,0 +1,61 @@
+module.exports = ({ _, moment, settings, actions }) =>
+  function getSchedule(schedules, isoWeekday, fromDate) {
+    const timezone = actions.getStoreTimezone();
+    let todayTZ = moment().tz(timezone);
+
+    if (fromDate) {
+      todayTZ = moment(fromDate).tz(timezone);
+    }
+
+    const day = isoWeekday || todayTZ.isoWeekday(); // monday 1 - sunday 7
+
+    let activeSchedules = _.get(settings, 'order.schedules', []).filter(
+      item => !item.departments || !item.departments.length
+    );
+
+    if (schedules && schedules.length) {
+      activeSchedules = schedules;
+    }
+
+    if (!activeSchedules.length) {
+      return {
+        todayTZ,
+        skipDays: [],
+        cutDay: 0,
+      };
+    }
+
+    const schedule = activeSchedules.find(item => {
+      const { dayOfWeek } = item || {};
+      if (!dayOfWeek || !dayOfWeek.length) return true;
+      return dayOfWeek.includes(day);
+    });
+
+    if (schedule) {
+      return {
+        ...schedule,
+        todayTZ,
+      };
+    }
+
+    for (let offset = 1; offset <= 7; offset += 1) {
+      const nextIsoWeekday = ((day - 1 + offset) % 7) + 1;
+      const nextSchedule = activeSchedules.find(item => {
+        const { dayOfWeek } = item || {};
+        return Array.isArray(dayOfWeek) && dayOfWeek.includes(nextIsoWeekday);
+      });
+
+      if (nextSchedule) {
+        return {
+          ...nextSchedule,
+          todayTZ: todayTZ.clone().add(offset, 'days'),
+        };
+      }
+    }
+
+    return {
+      todayTZ,
+      skipDays: [],
+      cutDay: 0,
+    };
+  };

package/lib/store/getStoreTimezone.js

@@ -0,0 +1,7 @@
+module.exports = ({ _, settings }) =>
+  function getStoreTimezone() {
+    return (
+      _.get(settings, 'localization.timezone', 'America/New_York') ||
+      'America/New_York'
+    );
+  };

package/lib/store/hasReadyDateCapacitySettings.js

@@ -0,0 +1,8 @@
+module.exports = ({ _, actions }) =>
+  function hasReadyDateCapacitySettings(days = []) {
+    return days.some(
+      day =>
+        actions.normalizeLimit(_.get(day, 'maxOrders')) > 0 ||
+        actions.normalizeLimit(_.get(day, 'maxItems')) > 0
+    );
+  };

package/lib/store/index.js

@@ -1,6 +1,14 @@
 //
 const getScheduleByCustomer = require('./getScheduleByCustomer');
 const isNeareastMultiple = require('./isNeareastMultiple');
+const getClosedDays = require('./getClosedDays');
+const getReadyDateCapacityDays = require('./getReadyDateCapacityDays');
+const getReadyDateCountsByDate = require('./getReadyDateCountsByDate');
+const getSchedule = require('./getSchedule');
+const getStoreTimezone = require('./getStoreTimezone');
+const hasReadyDateCapacitySettings = require('./hasReadyDateCapacitySettings');
+const normalizeLimit = require('./normalizeLimit');
+const pickBaseEndDate = require('./pickBaseEndDate');
 const pickEndDate = require('./pickEndDate');
 const pickEndDateByCustomer = require('./pickEndDateByCustomer');
 
@@ -13,8 +21,16 @@ const storeActions = (deps = {}) => {
   };
 
   const freezedActions = Object.freeze({
+    getClosedDays: getClosedDays(innerDeps),
+    getReadyDateCapacityDays: getReadyDateCapacityDays(innerDeps),
+    getReadyDateCountsByDate: getReadyDateCountsByDate(innerDeps),
     getScheduleByCustomer: getScheduleByCustomer(innerDeps),
+    getSchedule: getSchedule(innerDeps),
+    getStoreTimezone: getStoreTimezone(innerDeps),
+    hasReadyDateCapacitySettings: hasReadyDateCapacitySettings(innerDeps),
     isNeareastMultiple: isNeareastMultiple(innerDeps),
+    normalizeLimit: normalizeLimit(innerDeps),
+    pickBaseEndDate: pickBaseEndDate(innerDeps),
     pickEndDate: pickEndDate(innerDeps),
     pickEndDateByCustomer: pickEndDateByCustomer(innerDeps),
   });

package/lib/store/normalizeLimit.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function normalizeLimit(value) {
+    const parsedValue = Math.trunc(Number(value) || 0);
+    return parsedValue > 0 ? parsedValue : 0;
+  };

package/lib/store/pickBaseEndDate.js

@@ -0,0 +1,71 @@
+const { MAX_ADD_DAYS } = require('../constants/Store');
+
+module.exports = ({ moment, actions }) =>
+  function pickBaseEndDate(schedules, isoWeekday, fromDate) {
+    const {
+      addDays: addDaysParam,
+      readyHour,
+      cutHour,
+      cutDay,
+      skipDays,
+      todayTZ,
+    } = actions.getSchedule(schedules, isoWeekday, fromDate);
+
+    let endDateTZ = todayTZ.clone();
+    const closedDays = actions.getClosedDays();
+    const todayHours = todayTZ.get('hours');
+    const todayMinutes = todayTZ.get('minutes');
+
+    let addDays = 0;
+
+    if (
+      !fromDate &&
+      typeof addDaysParam === 'number' &&
+      addDaysParam <= MAX_ADD_DAYS
+    ) {
+      addDays = addDaysParam;
+    }
+
+    if (
+      (cutHour && todayHours > cutHour.hour) ||
+      (cutHour && todayHours >= cutHour.hour && todayMinutes > cutHour.minute)
+    ) {
+      endDateTZ = endDateTZ.add(cutDay, 'days');
+    }
+
+    if (readyHour && readyHour.hour !== undefined)
+      endDateTZ.set('hour', readyHour.hour);
+    if (readyHour && readyHour.minute !== undefined)
+      endDateTZ.set('minute', readyHour.minute);
+
+    endDateTZ.set('second', 0);
+
+    const isSkipDay = endDateIsoWeekDay => {
+      if (skipDays && skipDays.length >= 7) return false;
+
+      return skipDays && skipDays.includes(endDateIsoWeekDay);
+    };
+
+    const isClosedDay = endDate =>
+      closedDays.some(
+        closedDate => endDate.format('YYYY-MM-DD') === closedDate.date
+      );
+
+    let addedDays = 0;
+
+    while (
+      addedDays < addDays ||
+      isSkipDay(endDateTZ.isoWeekday()) ||
+      isClosedDay(endDateTZ)
+    ) {
+      if (
+        endDateTZ.isSame(todayTZ, 'day') ||
+        (!isSkipDay(endDateTZ.isoWeekday()) && !isClosedDay(endDateTZ))
+      ) {
+        addedDays += 1;
+      }
+      endDateTZ.add(1, 'days');
+    }
+
+    return moment.utc(endDateTZ).format();
+  };

package/lib/store/pickEndDate.js

@@ -1,108 +1,82 @@
-module.exports = ({ settings, _, moment }) => {
-  const timezone =
-    _.get(settings, 'localization.timezone', 'America/New_York') ||
-    'America/New_York';
-
-  const getSchedule = (schedules, isoWeekday) => {
-    const todayTZ = moment().tz(timezone);
-    const day = isoWeekday || todayTZ.isoWeekday(); // monday 1 - sunday 7
-    const _schedules =
-      schedules && schedules.length
-        ? schedules
-        : _.get(settings, 'order.schedules', []).filter(
-            item => !item.departments || !item.departments.length
-          );
-
-    if (!_schedules.length) {
-      return {
-        todayTZ,
-        skipDays: [],
-        cutDay: 0,
-      };
-    }
+const { MAX_ADD_DAYS } = require('../constants/Store');
+
+module.exports = ({ _, moment, actions }) =>
+  function pickEndDate(
+    schedules,
+    isoWeekday,
+    fromDate,
+    readyDateCapacityCounts = []
+  ) {
+    const timezone = actions.getStoreTimezone();
+
+    let candidateDate = actions.pickBaseEndDate(
+      schedules,
+      isoWeekday,
+      fromDate
+    );
+
+    const readyDateCapacityDays = actions.getReadyDateCapacityDays();
+    if (!actions.hasReadyDateCapacitySettings(readyDateCapacityDays))
+      return candidateDate;
+
+    const countsByDate = actions.getReadyDateCountsByDate(
+      readyDateCapacityCounts
+    );
+    if (!countsByDate.size) return candidateDate;
+
+    const inspectedDays = new Set();
+
+    for (let index = 0; index < MAX_ADD_DAYS; index += 1) {
+      const candidateMomentTZ = moment(candidateDate).tz(timezone);
+      const candidateLocalDateKey = candidateMomentTZ.format('YYYY-MM-DD');
+
+      if (inspectedDays.has(candidateLocalDateKey)) break;
+      inspectedDays.add(candidateLocalDateKey);
+
+      const capacitySettingsForDay = readyDateCapacityDays.find(
+        day => Number(_.get(day, 'day')) === candidateMomentTZ.isoWeekday()
+      );
 
-    const schedule = _schedules.find(item => {
-      const { dayOfWeek } = item || {};
-      if (!dayOfWeek || !dayOfWeek.length) return true;
-      return dayOfWeek.includes(day);
-    });
+      if (!capacitySettingsForDay) return candidateDate;
 
-    return {
-      ...schedule,
-      todayTZ,
-    };
-  };
+      const maxOrders = actions.normalizeLimit(
+        _.get(capacitySettingsForDay, 'maxOrders')
+      );
+      const maxItems = actions.normalizeLimit(
+        _.get(capacitySettingsForDay, 'maxItems')
+      );
 
-  const getClosedDays = () => {
-    const schedule = _.get(settings, 'schedule', {});
-    const { closed = [] } = schedule;
-    if (!Array.isArray(closed)) return [];
-    return closed;
-  };
+      if (maxOrders <= 0 && maxItems <= 0) return candidateDate;
 
-  const MAX_ADD_DAYS = 365;
-
-  return function pickEndDate(schedules, isoWeekday) {
-    const {
-      addDays: addDaysParam,
-      readyHour,
-      cutHour,
-      cutDay,
-      skipDays,
-      todayTZ,
-    } = getSchedule(schedules, isoWeekday);
-
-    let endDateTZ = todayTZ.clone();
-    const closedDays = getClosedDays();
-    const todayHours = todayTZ.get('hours');
-    const todayMinutes = todayTZ.get('minutes');
-
-    const addDays =
-      typeof addDaysParam !== 'number' || addDaysParam > MAX_ADD_DAYS
-        ? 0
-        : addDaysParam;
-
-    if (
-      (cutHour && todayHours > cutHour.hour) ||
-      (cutHour && todayHours >= cutHour.hour && todayMinutes > cutHour.minute)
-    ) {
-      endDateTZ = endDateTZ.add(cutDay, 'days');
-    }
+      const candidateUTCDateKey = moment
+        .utc(candidateDate)
+        .format('YYYY-MM-DD');
+      const dayCount = countsByDate.get(candidateUTCDateKey) || {
+        totalOrders: 0,
+        totalItems: 0,
+      };
 
-    if (readyHour && readyHour.hour !== undefined)
-      endDateTZ.set('hour', readyHour.hour);
-    if (readyHour && readyHour.minute !== undefined)
-      endDateTZ.set('minute', readyHour.minute);
+      const isUnavailable =
+        (maxOrders > 0 && dayCount.totalOrders >= maxOrders) ||
+        (maxItems > 0 && dayCount.totalItems >= maxItems);
 
-    endDateTZ.set('second', 0);
+      if (!isUnavailable) return candidateDate;
 
-    const isSkipDay = endDateIsoWeekDay => {
-      if (skipDays && skipDays.length >= 7) return false;
+      const nextDateSeed = candidateMomentTZ
+        .clone()
+        .add(1, 'day')
+        .startOf('day')
+        .toISOString();
 
-      return skipDays && skipDays.includes(endDateIsoWeekDay);
-    };
+      const { readyHour, cutHour, cutDay, skipDays } =
+        actions.getSchedule(schedules, undefined, candidateDate) || {};
 
-    const isClosedDay = endDate =>
-      closedDays.some(
-        closedDate => endDate.format('YYYY-MM-DD') === closedDate.date
+      candidateDate = actions.pickBaseEndDate(
+        [{ readyHour, cutHour, cutDay, skipDays }],
+        undefined,
+        nextDateSeed
       );
-
-    let addedDays = 0;
-
-    while (
-      addedDays < addDays ||
-      isSkipDay(endDateTZ.isoWeekday()) ||
-      isClosedDay(endDateTZ)
-    ) {
-      if (
-        endDateTZ.isSame(todayTZ, 'day') ||
-        (!isSkipDay(endDateTZ.isoWeekday()) && !isClosedDay(endDateTZ))
-      ) {
-        addedDays += 1;
-      }
-      endDateTZ.add(1, 'days');
     }
 
-    return moment.utc(endDateTZ).format();
+    return candidateDate;
   };
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.145",
+  "version": "1.0.147",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -54,5 +54,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "eb6adf31020d7ca3b57f6e6b1bfa20c4e0289ca0"
+  "gitHead": "c983de0f3b8d4978e2fb0b68551ba347dbdc4d55"
 }