@darkpos/pricing 1.0.92 → 1.0.93

package/__TEST__/order/conditionsNotMet.test.js

@@ -884,4 +884,128 @@ describe('Conditions not met for the item', () => {
     expect(order.items[1].total).toBe(20);
     expect(order.items[1].modifiers.length).toBe(1);
   });
+
+  test('Payment type condition is met (payment modifier and using prepay at the same time)', () => {
+    const prePayDiscount1Usd = {
+      _id: '6819114c06c23d37c1f19412',
+      name: '1 usd pre pay disc',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'paymentMethods',
+            value: ['cash'],
+            operand: '$in',
+          },
+          {
+            key: 'paymentTypes',
+            value: ['cash'],
+            operand: '$in',
+          },
+          {
+            key: 'payment',
+            value: 'prepay',
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        type: 'fixed',
+        action: 'subtract',
+        amount: 1,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [prePayDiscount1Usd],
+    };
+
+    const resultedOrder = pricingService.order.calculate(
+      {
+        id: 'ord-123',
+        items: [item],
+        modifiers: [],
+      },
+      {
+        paymentMethod: 'cash',
+        paymentType: 'cash',
+      }
+    );
+
+    expect(resultedOrder.total).toBe(10);
+    expect(resultedOrder.items[0].total).toBe(10);
+    expect(resultedOrder.items[0].modifiers[0]._computed.amount).toBe(0);
+
+    const resultedOrderPrepay = pricingService.order.calculate(resultedOrder, {
+      paymentMethod: 'cash',
+      paymentType: 'cash',
+      isPrepay: true,
+    });
+
+    expect(resultedOrderPrepay.total).toBe(9);
+    expect(resultedOrderPrepay.items[0].total).toBe(9);
+    expect(resultedOrderPrepay.items[0].modifiers[0]._computed.amount).toBe(0);
+    expect(resultedOrderPrepay.items[0].modifiers[1]._computed.amount).toBe(-1);
+  });
+
+  test('Payment type condition is met (using only prepay rule)', () => {
+    const prePayDiscount1Usd = {
+      _id: '6819114c06c23d37c1f19412',
+      name: '1 usd pre pay disc',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'payment',
+            value: 'prepay',
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        type: 'fixed',
+        action: 'subtract',
+        amount: 1,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [prePayDiscount1Usd],
+    };
+
+    const resultedOrder = pricingService.order.calculate({
+      id: 'ord-123',
+      items: [item],
+      modifiers: [],
+    });
+
+    expect(resultedOrder.total).toBe(10);
+    expect(resultedOrder.items[0].total).toBe(10);
+    expect(resultedOrder.items[0].modifiers[0]._computed.amount).toBe(0);
+
+    const resultedOrderPrepay = pricingService.order.calculate(resultedOrder, {
+      isPrepay: true,
+    });
+
+    expect(resultedOrderPrepay.total).toBe(9);
+    expect(resultedOrderPrepay.items[0].total).toBe(9);
+    expect(resultedOrderPrepay.items[0].modifiers[0]._computed.amount).toBe(0);
+    expect(resultedOrderPrepay.items[0].modifiers[1]._computed.amount).toBe(-1);
+    expect(resultedOrderPrepay.items[0].modifiers[1].properties).toMatchObject({
+      isCalculatedPaymentModifier: true,
+      paymentId: undefined,
+    });
+  });
 });

package/__TEST__/order/getParentTotals.test.js

@@ -0,0 +1,79 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+describe('Get parent totals', () => {
+  it('should return zero totals if input is not an array', () => {
+    expect(pricingService.order.getTotals(null)).toEqual({
+      total: 0,
+      subTotal: 0,
+      subTotals: {},
+    });
+  });
+
+  it('should calculate totals for simple sub-orders', () => {
+    const orders = [
+      {
+        parentId: '123',
+        total: 10,
+        subTotal: 8,
+        subTotals: {
+          base: 8,
+          tax: 2,
+        },
+      },
+      {
+        parentId: '123',
+        total: 20,
+        subTotal: 18,
+        subTotals: {
+          base: 18,
+          tax: 2,
+        },
+      },
+    ];
+
+    expect(pricingService.order.getTotals(orders)).toEqual({
+      total: 30,
+      subTotal: 26,
+      subTotals: {
+        base: 26,
+        tax: 4,
+      },
+    });
+  });
+
+  it('should merge subtotals with missing keys', () => {
+    const orders = [
+      {
+        parentId: '1',
+        total: 5,
+        subTotal: 5,
+        subTotals: {
+          fee: 1,
+        },
+      },
+      {
+        parentId: '1',
+        total: 10,
+        subTotal: 10,
+        subTotals: {
+          tax: 2,
+        },
+      },
+    ];
+
+    expect(pricingService.order.getTotals(orders)).toEqual({
+      total: 15,
+      subTotal: 15,
+      subTotals: {
+        fee: 1,
+        tax: 2,
+      },
+    });
+  });
+});

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

@@ -44,40 +44,28 @@ describe('Order actions', () => {
       total: 10,
       totalPaid: 0,
     };
-
     let cashPercentageDiscountOrder = pricingService.order.calculate(
       { items: [orderItem] },
       { paymentType: 'cash' }
     );
-
     expect(cashPercentageDiscountOrder).toHaveProperty('total', 9);
     expect(cashPercentageDiscountOrder).toHaveProperty('subTotal', 10);
     expect(cashPercentageDiscountOrder).toHaveProperty('subTotals', {
       discount: -1,
     });
     expect(cashPercentageDiscountOrder.items[0].modifiers).toHaveLength(2);
-
     expect(cashPercentageDiscountOrder.items[0].modifiers[0]._computed).toEqual(
       expect.objectContaining({
         amount: 0,
         description: 'CASH 10% DISCOUNT',
       })
     );
-
     expect(cashPercentageDiscountOrder.items[0].modifiers[1]._computed).toEqual(
       expect.objectContaining({
         amount: -1,
         description: '$1.00 discount (-$1.00)',
       })
     );
-
-    expect(cashPercentageDiscountOrder.items[0].modifiers[0]._computed).toEqual(
-      expect.objectContaining({
-        amount: 0,
-        description: 'CASH 10% DISCOUNT',
-      })
-    );
-
     cashPercentageDiscountOrder = pricingService.order.calculate(
       { items: [orderItem] },
       {
@@ -88,14 +76,12 @@ describe('Order actions', () => {
       }
     );
     cashPercentageDiscountOrder.items[0].totalPaid = 1;
-
     expect(cashPercentageDiscountOrder).toHaveProperty('total', 9.89);
     expect(cashPercentageDiscountOrder).toHaveProperty('subTotal', 10);
     expect(cashPercentageDiscountOrder).toHaveProperty('subTotals', {
       discount: -0.1111111111111112,
     });
     expect(cashPercentageDiscountOrder.items[0].modifiers).toHaveLength(2);
-
     cashPercentageDiscountOrder = pricingService.order.calculate(
       cashPercentageDiscountOrder,
       {
@@ -106,7 +92,6 @@ describe('Order actions', () => {
       }
     );
     cashPercentageDiscountOrder.items[0].totalPaid = 3;
-
     expect(cashPercentageDiscountOrder).toHaveProperty('total', 9.67);
     expect(cashPercentageDiscountOrder).toHaveProperty('subTotal', 10);
     expect(cashPercentageDiscountOrder).toHaveProperty('subTotals', {
@@ -141,7 +126,6 @@ describe('Order actions', () => {
         paymentId: '111',
       })
     );
-
     cashPercentageDiscountOrder = pricingService.order.calculate(
       cashPercentageDiscountOrder,
       {
@@ -151,7 +135,6 @@ describe('Order actions', () => {
         paymentId: '333',
       }
     );
-
     expect(cashPercentageDiscountOrder).toHaveProperty('total', 9);
     expect(cashPercentageDiscountOrder).toHaveProperty('subTotal', 10);
     expect(cashPercentageDiscountOrder).toHaveProperty('subTotals', {
@@ -1128,4 +1111,336 @@ describe('Order actions', () => {
       })
     );
   });
+
+  test('Applies fixed and percentage discounts with fixed modifier added first (both payment modifiers)', () => {
+    const prePayDiscount1Usd = {
+      _id: '6819114c06c23d37c1f19412',
+      name: '1 usd pre pay disc',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'paymentTypes',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        type: 'fixed',
+        action: 'subtract',
+        amount: 1,
+      },
+    };
+
+    const cashDiscount10Percent = {
+      _id: '6819114c06c23d37c1f19412',
+      name: '10 % cash discount',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'paymentTypes',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 10,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [prePayDiscount1Usd, cashDiscount10Percent],
+    };
+
+    const resultedOrderPrepay = pricingService.item.calculate(item, {
+      paymentType: 'cash',
+      paymentMethod: 'cash',
+      isPrepay: true,
+      lockPaymentModifiers: true,
+      paymentId: 'abcd123',
+      amountToPay: 8,
+    });
+
+    expect(resultedOrderPrepay.total).toBe(8);
+
+    expect(resultedOrderPrepay.modifiers[0]._computed.amount).toBe(0);
+    expect(resultedOrderPrepay.modifiers[1]._computed.amount).toBe(0);
+    expect(resultedOrderPrepay.modifiers[2]._computed.amount).toBe(-1);
+    expect(resultedOrderPrepay.modifiers[3]._computed.amount).toBe(-1);
+  });
+
+  test('Applies percentage and fixed discounts with percentage modifier added first (both paymentModifiers)', () => {
+    const prePayDiscount1Usd = {
+      _id: '6819114c06c23d37c1f19412',
+      name: '1 usd pre pay disc',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'paymentTypes',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        type: 'fixed',
+        action: 'subtract',
+        amount: 1,
+      },
+    };
+
+    const cashDiscount10Percent = {
+      _id: '6819114c06c23d37c1f19412',
+      name: '10 % cash discount',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'paymentTypes',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 10,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [cashDiscount10Percent, prePayDiscount1Usd],
+    };
+
+    const resultedOrderPrepay = pricingService.item.calculate(item, {
+      paymentType: 'cash',
+      paymentMethod: 'cash',
+      isPrepay: true,
+      lockPaymentModifiers: true,
+      paymentId: 'abcd123',
+      amountToPay: 8,
+    });
+
+    expect(resultedOrderPrepay.total).toBe(8);
+
+    expect(resultedOrderPrepay.modifiers[0]._computed.amount).toBe(0);
+    expect(resultedOrderPrepay.modifiers[1]._computed.amount).toBe(0);
+    expect(resultedOrderPrepay.modifiers[2]._computed.amount).toBe(-1);
+    expect(resultedOrderPrepay.modifiers[3]._computed.amount).toBe(-1);
+  });
+
+  test('Applies one payment discount and one regular fixed discount (percentage first)', () => {
+    const prePayDiscount1Usd = {
+      _id: '6819114c06c23d37c1f19412',
+      name: '1 usd pre pay disc',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [],
+      },
+      compute: {
+        type: 'fixed',
+        action: 'subtract',
+        amount: 1,
+      },
+    };
+
+    const cashDiscount10Percent = {
+      _id: '6819114c06c23d37c1f19412',
+      name: '10 % cash discount',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'paymentTypes',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 10,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [cashDiscount10Percent, prePayDiscount1Usd],
+    };
+
+    const resultedOrderPrepay = pricingService.item.calculate(item, {
+      paymentType: 'cash',
+      paymentMethod: 'cash',
+      isPrepay: true,
+      lockPaymentModifiers: true,
+      paymentId: 'abcd123',
+      amountToPay: 8,
+    });
+
+    expect(resultedOrderPrepay.total).toBe(8);
+
+    expect(resultedOrderPrepay.modifiers[0]._computed.amount).toBe(0);
+    expect(resultedOrderPrepay.modifiers[1]._computed.amount).toBe(-1);
+    expect(resultedOrderPrepay.modifiers[2]._computed.amount).toBe(-1);
+  });
+
+  test('Applies one payment discount and one regular percentage discount (fixed first)', () => {
+    const prePayDiscount1Usd = {
+      _id: '6819114c06c23d37c1f19412',
+      name: '1 usd pre pay disc',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [],
+      },
+      compute: {
+        type: 'fixed',
+        action: 'subtract',
+        amount: 1,
+      },
+    };
+
+    const cashDiscount10Percent = {
+      _id: '6819114c06c23d37c1f19412',
+      name: '10 % cash discount',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'paymentTypes',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 10,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [prePayDiscount1Usd, cashDiscount10Percent],
+    };
+
+    const resultedOrderPrepay = pricingService.item.calculate(item, {
+      paymentType: 'cash',
+      paymentMethod: 'cash',
+      isPrepay: true,
+      lockPaymentModifiers: true,
+      paymentId: 'abcd123',
+      amountToPay: 8,
+    });
+
+    expect(resultedOrderPrepay.total).toBe(8);
+
+    expect(resultedOrderPrepay.modifiers[0]._computed.amount).toBe(0);
+    expect(resultedOrderPrepay.modifiers[1]._computed.amount).toBe(-1);
+    expect(resultedOrderPrepay.modifiers[2]._computed.amount).toBe(-1);
+  });
+
+  test('Applies one payment discount and one regular percentage discount (fixed first) withouth sending amountToPay', () => {
+    const prePayDiscount1Usd = {
+      _id: '6819114c06c23d37c1f19412',
+      name: '1 usd pre pay disc',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [],
+      },
+      compute: {
+        type: 'fixed',
+        action: 'subtract',
+        amount: 1,
+      },
+    };
+
+    const cashDiscount10Percent = {
+      _id: '6819114c06c23d37c1f19412',
+      name: '10 % cash discount',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'paymentTypes',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 10,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [prePayDiscount1Usd, cashDiscount10Percent],
+    };
+
+    const resultedOrderPrepay = pricingService.item.calculate(item, {
+      paymentType: 'cash',
+      paymentMethod: 'cash',
+      isPrepay: true,
+      paymentId: 'abcd123',
+    });
+
+    expect(resultedOrderPrepay.total).toBe(8);
+
+    expect(resultedOrderPrepay.modifiers[0]._computed.amount).toBe(0);
+    expect(resultedOrderPrepay.modifiers[1]._computed.amount).toBe(-1);
+    expect(resultedOrderPrepay.modifiers[2]._computed.amount).toBe(-1);
+  });
 });

package/lib/item/calculate.js

@@ -9,6 +9,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       typeof opts.amountToPay === 'number' ? opts.amountToPay : 0;
     const paymentMethod = opts.paymentMethod || null;
     const paymentType = opts.paymentType || null;
+    const isPrepay = opts.isPrepay || false;
     const startRequestDate = opts.startRequestDate || null;
     const endRequestDate = opts.endRequestDate || null;
     const lockPaymentModifiers = !!opts.lockPaymentModifiers;
@@ -70,6 +71,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
             paymentModifier: modifier,
             paymentMethod,
             paymentType,
+            isPrepay,
           })
       )
       .filter(paymentModifier => {
@@ -116,6 +118,8 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       let prvPrice = 0;
       let prvSort;
 
+      let accumulatedAmount = 0;
+
       for (const modifier of sortedModifiers) {
         const included = modifierActions.isIncluded(modifier);
         const direct = modifierActions.isDirect(modifier);
@@ -132,7 +136,10 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         if (modifierActions.isPaymentModifier(modifier)) {
           _modifier = modifierActions.calculatePaymentModifier({
             paymentModifier: modifier,
-            amountToPay,
+            amountToPay:
+              accumulatedAmount < 0 && amountToPay > 0
+                ? math.add(amountToPay, math.abs(accumulatedAmount))
+                : amountToPay,
             itemBalance:
               typeof item.totalPaid === 'number' && item.totalPaid > 0
                 ? actions.getItemsBalance({ items: [item] })
@@ -140,6 +147,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
             paymentMethod,
             paymentType,
             paymentId,
+            isPrepay,
           });
         }
 
@@ -168,6 +176,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
           computedAmount = _computed.amount;
 
         prvPrice = math.add(prvPrice, math.div(_computed.amount, quantity));
+        accumulatedAmount = math.add(accumulatedAmount, _computed.amount);
         prvSort = sort;
 
         ({ subTotals, total } = actions.getTotals({

package/lib/item/hasPaymentMethodType.js

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

package/lib/modifier/areConditionsMet.js

@@ -92,6 +92,9 @@ module.exports = ({ actions, utils }) => {
               return false;
             case 'paymentTypes':
               return false;
+            case 'payment': {
+              return false;
+            }
             default:
               return false;
           }

package/lib/modifier/calculatePaymentModifier.js

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

package/lib/modifier/hasPaymentMethodType.js

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

package/lib/modifier/index.js

@@ -163,6 +163,7 @@ const isOrderUseValid = require('./isOrderUseValid');
 const getMaxItemQuantity = require('./getMaxItemQuantity');
 const createDescription = require('./createDescription');
 const patchModifier = require('./patchModifier');
+const isPrepayModifier = require('./isPrepayModifier');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -339,6 +340,7 @@ const modifierActions = (deps = {}) => {
     getCreditModifiersTotalEntities: getCreditModifiersTotalEntities(innerDeps),
     createDescription: createDescription(innerDeps),
     patchModifier: patchModifier(innerDeps),
+    isPrepayModifier: isPrepayModifier(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isPaymentModifier.js

@@ -2,6 +2,7 @@ module.exports = ({ actions }) =>
   function isPaymentModifier(modifier) {
     return (
       actions.isPaymentTypeModifier(modifier) ||
-      actions.isPaymentMethodModifier(modifier)
+      actions.isPaymentMethodModifier(modifier) ||
+      actions.isPrepayModifier(modifier)
     );
   };

package/lib/modifier/isPercentage.js

@@ -1,6 +1,6 @@
 module.exports = ({ constants }) => {
   const { Modifier } = constants;
-  return function isFixed(modifier) {
+  return function isPercentage(modifier) {
     return !!(
       modifier &&
       modifier.compute &&

package/lib/modifier/isPrepayModifier.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function isPrepayModifier(modifier) {
+    return !!(
+      modifier &&
+      modifier.conditions &&
+      Array.isArray(modifier.conditions.rules) &&
+      modifier.conditions.rules.some(
+        condition => condition.key === 'payment' && condition.value === 'prepay'
+      )
+    );
+  };

package/lib/modifier/sort.js

@@ -2,7 +2,6 @@
 module.exports = ({ actions }) => {
   function compareValues(key, order = 'asc') {
     return function innerSort(a, b) {
-      // property doesn't exist on either object
       const aVal = actions.getProperty(a, key);
       const bVal = actions.getProperty(b, key);
 
@@ -13,38 +12,27 @@ module.exports = ({ actions }) => {
       const bIsCalculatedPaymentModifier =
         actions.isCalculatedPaymentModifier(b);
 
-      if (aIsCalculatedPaymentModifier && bIsPaymentModifier && aVal === null) {
-        return -1;
-      }
-      if (bIsCalculatedPaymentModifier && aIsPaymentModifier && bVal === null) {
-        return -1;
-      }
+      const aIsPercentageNoSort = actions.isPercentage(a) && aVal == null;
+      const bIsPercentageNoSort = actions.isPercentage(b) && bVal == null;
 
-      if (
-        (aIsPaymentModifier || aIsCalculatedPaymentModifier) &&
-        aVal === null
-      ) {
+      if (bIsPaymentModifier && aIsPercentageNoSort && !bIsPercentageNoSort)
         return 1;
-      }
-
-      if (
-        (bIsPaymentModifier || bIsCalculatedPaymentModifier) &&
-        bVal === null
-      ) {
-        return 1;
-      }
-
-      if (aVal == null && bVal === null) {
-        return 0;
-      }
+      if (aIsPaymentModifier && !aIsPercentageNoSort && bIsPercentageNoSort)
+        return -1;
 
-      if (aVal == null) {
+      if (aIsCalculatedPaymentModifier && bIsPaymentModifier && aVal === null)
+        return -1;
+      if (bIsCalculatedPaymentModifier && aIsPaymentModifier && bVal === null)
         return -1;
-      }
 
-      if (bVal === null) {
+      if ((aIsPaymentModifier || aIsCalculatedPaymentModifier) && aVal === null)
+        return 1;
+      if ((bIsPaymentModifier || bIsCalculatedPaymentModifier) && bVal === null)
         return 1;
-      }
+
+      if (aVal == null && bVal === null) return 0;
+      if (aVal == null) return -1;
+      if (bVal === null) return 1;
 
       const varA = typeof aVal === 'string' ? aVal.toUpperCase() : aVal;
       const varB = typeof bVal === 'string' ? bVal.toUpperCase() : bVal;
@@ -52,6 +40,7 @@ module.exports = ({ actions }) => {
       let comparison = 0;
       if (varA > varB) comparison = 1;
       else if (varA < varB) comparison = -1;
+
       return order === 'desc' ? comparison * -1 : comparison;
     };
   }

package/lib/order/getTotals.js

@@ -1,29 +1,28 @@
 module.exports = ({ utils }) => {
   const { math } = utils;
+
   return function getTotals(orders) {
-    if (!Array.isArray(orders)) return { total: 0, subTotals: {} };
-    return orders
-      .filter(each => !!each.parentId || !each.isParent)
-      .reduce(
-        (acc, order) => {
-          const subTotals = {};
-          const { subTotals: orderSubTotals } = order;
-          if (orderSubTotals) {
-            const keys = Object.keys(orderSubTotals);
-            // eslint-disable-next-line no-restricted-syntax
-            for (const key of keys)
-              subTotals[key] = math.add(
-                acc.subTotals[key] || 0,
-                orderSubTotals[key]
-              );
+    if (!Array.isArray(orders)) {
+      return { total: 0, subTotal: 0, subTotals: {} };
+    }
+
+    return orders.reduce(
+      (acc, order) => {
+        const { subTotals: orderSubTotals, subTotal = 0, total = 0 } = order;
+
+        if (orderSubTotals) {
+          // eslint-disable-next-line no-restricted-syntax
+          for (const [key, value] of Object.entries(orderSubTotals)) {
+            acc.subTotals[key] = math.add(acc.subTotals[key] || 0, value);
           }
+        }
+
+        acc.total = math.add(acc.total, total);
+        acc.subTotal = math.add(acc.subTotal, subTotal);
 
-          return {
-            total: math.add(acc.total, order.total),
-            subTotals,
-          };
-        },
-        { total: 0, subTotals: {} }
-      );
+        return acc;
+      },
+      { total: 0, subTotal: 0, subTotals: {} }
+    );
   };
 };

package/lib/order/splitItems.js

@@ -1,4 +1,4 @@
-module.exports = ({ actions, modifierActions, itemActions }) =>
+module.exports = ({ actions, modifierActions, itemActions, utils }) =>
   function splitItems({ order }) {
     if (!order || !order.items) return order;
 
@@ -32,6 +32,7 @@ module.exports = ({ actions, modifierActions, itemActions }) =>
           ...item,
           quantity: splitQty,
           modifiers: [],
+          _id: utils.helpers.getObjectID(),
         });
         remaining -= splitQty;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.92",
+  "version": "1.0.93",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -27,6 +27,7 @@
     "test:modifier": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/modifier.test.js",
     "test:paymentModifiers": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/order-payment-modifier.test.js",
     "test:addItem": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/addItem.test.js",
+    "test:getParentTotals": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/getParentTotals.test.js",
     "lint": "eslint --quiet lib/"
   },
   "publishConfig": {
@@ -51,5 +52,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "ae4955dc540555ef6c2e4b8c758e9d8df4d0a03c"
+  "gitHead": "fb466ad4fdad14d593a1ee3dc2814f683b10ec24"
 }