@darkpos/pricing 1.0.22 → 1.0.23

package/__TEST__/order/order.test.js

@@ -94,7 +94,6 @@ describe('Order actions', () => {
     expect(newOrder).toHaveProperty('subTotals', {
       discount: -6,
     });
-    // console.log(JSON.stringify(newOrder, 0, 2));
   });
   test('Get calculated Order, multiple items and indirect modifiers', () => {
     const item1 = {
@@ -125,23 +124,23 @@ describe('Order actions', () => {
     expect(newOrder).toHaveProperty('subTotals', {
       discount: -2,
     });
-    expect(newOrder.items[0]).toHaveProperty('total', 58.28);
+    expect(newOrder.items[0]).toHaveProperty('total', 58.29);
     expect(newOrder.items[0]).toHaveProperty('subTotals', {
-      discount: -1.72,
+      discount: -1.71,
       _included: 0,
-      _xincluded: -1.72,
+      _xincluded: -1.71,
       _direct: 0,
-      _xdirect: -1.72,
+      _xdirect: -1.71,
       _simple: 60,
       _actual: 60,
     });
-    expect(newOrder.items[1]).toHaveProperty('total', 9.72);
+    expect(newOrder.items[1]).toHaveProperty('total', 9.71);
     expect(newOrder.items[1]).toHaveProperty('subTotals', {
-      discount: -0.28,
+      discount: -0.29,
       _included: 0,
-      _xincluded: -0.28,
+      _xincluded: -0.29,
       _direct: 0,
-      _xdirect: -0.28,
+      _xdirect: -0.29,
       _simple: 10,
       _actual: 10,
     });
@@ -169,10 +168,10 @@ describe('Order actions', () => {
 
     const order = { items: [item1, item2], modifiers: [modifier1] };
     const newOrder = pricingService.order.calculate(order);
-    expect(newOrder).toHaveProperty('total', 18.58);
+    expect(newOrder).toHaveProperty('total', 18.57);
     expect(newOrder).toHaveProperty('subTotal', 20.64);
     expect(newOrder).toHaveProperty('subTotals', {
-      discount: -2.06,
+      discount: -2.07,
     });
     expect(newOrder.items[0]).toHaveProperty('total', 14.39);
     expect(newOrder.items[0]).toHaveProperty('subTotals', {
@@ -184,13 +183,13 @@ describe('Order actions', () => {
       _simple: 15.99,
       _actual: 15.99,
     });
-    expect(newOrder.items[1]).toHaveProperty('total', 4.19);
+    expect(newOrder.items[1]).toHaveProperty('total', 4.18);
     expect(newOrder.items[1]).toHaveProperty('subTotals', {
-      discount: -0.46,
+      discount: -0.47,
       _included: 0,
-      _xincluded: -0.46,
+      _xincluded: -0.47,
       _direct: 0,
-      _xdirect: -0.46,
+      _xdirect: -0.47,
       _simple: 4.65,
       _actual: 4.65,
     });
@@ -627,19 +626,649 @@ describe('Order actions', () => {
     });
   });
 
+  test('CU-861n7pum9 - Get calculated Order, multiple items, 2 modifiers: 1 order discount (sort 1), 1 order tax (sort 99)', () => {
+    const item1 = {
+      _id: 1,
+      price: 44,
+      quantity: 2,
+    };
+    const item2 = {
+      _id: 2,
+      price: 14.95,
+      quantity: 1,
+    };
+    const item3 = {
+      _id: 3,
+      price: 2.15,
+      quantity: 3,
+    };
+    const discountMod = {
+      _id: 1,
+      compute: {
+        amount: 15,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: `15% Discount`,
+      type: 'discount',
+      properties: {
+        sort: 1,
+      },
+    };
+    const taxMod = {
+      _id: 2,
+      name: `7.75% tax`,
+      type: 'tax',
+      compute: {
+        amount: 7.75,
+        type: 'percentage',
+        action: 'add',
+      },
+      properties: {
+        sort: 99,
+      },
+    };
+
+    const order = {
+      items: [item1, item2, item3],
+      modifiers: [discountMod, taxMod],
+    };
+
+    const newOrder = pricingService.order.calculate(order);
+
+    expect(newOrder).toHaveProperty('total', 100.2);
+    expect(newOrder).toHaveProperty('subTotal', 109.4);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -16.41,
+      tax: 7.21,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 80.6);
+    expect(newOrder.items[1]).toHaveProperty('total', 13.7);
+    expect(newOrder.items[2]).toHaveProperty('total', 5.9);
+    expect(newOrder.items[0].modifiers[0].compute).toHaveProperty(
+      'amount',
+      13.2
+    );
+    expect(newOrder.items[0].modifiers[1].compute).toHaveProperty(
+      'amount',
+      5.8
+    );
+
+    expect(newOrder.items[1].modifiers[0].compute).toHaveProperty(
+      'amount',
+      2.24
+    );
+    expect(newOrder.items[1].modifiers[1].compute).toHaveProperty(
+      'amount',
+      0.99
+    );
+
+    expect(newOrder.items[2].modifiers[0].compute).toHaveProperty(
+      'amount',
+      0.97
+    );
+    expect(newOrder.items[2].modifiers[1].compute).toHaveProperty(
+      'amount',
+      0.42
+    );
+  });
+
+  test(`CU-861n7pum9 -  Get calculated Order, multiple items, 2 modifiers: 1 order discount (sort 1), 1 item tax (sort 99)`, () => {
+    const taxMod = {
+      _id: 2,
+      name: `7.75% tax`,
+      type: 'tax',
+      compute: {
+        amount: 7.75,
+        type: 'percentage',
+        action: 'add',
+      },
+      properties: {
+        sort: 99,
+      },
+    };
+
+    const discountMod = {
+      _id: 1,
+      compute: {
+        amount: 15,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: `15% Discount`,
+      type: 'discount',
+      properties: {
+        sort: 1,
+      },
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 44,
+      quantity: 2,
+      modifiers: [taxMod],
+    };
+    const item2 = {
+      _id: 2,
+      price: 14.95,
+      quantity: 1,
+      modifiers: [taxMod],
+    };
+    const item3 = {
+      _id: 3,
+      price: 2.15,
+      quantity: 3,
+      modifiers: [taxMod],
+    };
+
+    const order = {
+      items: [item1, item2, item3],
+      modifiers: [discountMod],
+    };
+
+    const newOrder = pricingService.order.calculate(order);
+
+    expect(newOrder).toHaveProperty('total', 100.2);
+    expect(newOrder).toHaveProperty('subTotal', 109.4);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -16.41,
+      tax: 7.21,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 80.6);
+    expect(newOrder.items[1]).toHaveProperty('total', 13.7);
+    expect(newOrder.items[2]).toHaveProperty('total', 5.9);
+    expect(newOrder.items[0].modifiers[0].compute).toHaveProperty(
+      'amount',
+      13.2
+    );
+    expect(newOrder.items[0].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      5.797
+    );
+
+    expect(newOrder.items[1].modifiers[0].compute).toHaveProperty(
+      'amount',
+      2.24
+    );
+    expect(newOrder.items[1].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0.985025
+    );
+
+    expect(newOrder.items[2].modifiers[0].compute).toHaveProperty(
+      'amount',
+      0.97
+    );
+    expect(newOrder.items[2].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0.4247
+    );
+  });
+
+  test('CU-861n7pum9 - Get calculated Order, multiple items, 2 modifiers: 1 item discount (sort 1), 1 item tax (sort 99)', () => {
+    const taxMod = {
+      _id: 2,
+      name: `7.75% tax`,
+      type: 'tax',
+      compute: {
+        amount: 7.75,
+        type: 'percentage',
+        action: 'add',
+      },
+      properties: {
+        sort: 99,
+      },
+    };
+
+    const discountMod = {
+      _id: 1,
+      compute: {
+        amount: 15,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: `15% Discount`,
+      type: 'discount',
+      properties: {
+        sort: 1,
+      },
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 44,
+      quantity: 2,
+      modifiers: [taxMod, discountMod],
+    };
+    const item2 = {
+      _id: 2,
+      price: 14.95,
+      quantity: 1,
+      modifiers: [taxMod, discountMod],
+    };
+    const item3 = {
+      _id: 3,
+      price: 2.15,
+      quantity: 3,
+      modifiers: [taxMod, discountMod],
+    };
+
+    const order = {
+      items: [item1, item2, item3],
+      modifiers: [],
+    };
+
+    const newOrder = pricingService.order.calculate(order);
+
+    expect(newOrder).toHaveProperty('total', 100.2);
+    expect(newOrder).toHaveProperty('subTotal', 109.4);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -16.41,
+      tax: 7.21,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 80.6);
+    expect(newOrder.items[1]).toHaveProperty('total', 13.69);
+    expect(newOrder.items[2]).toHaveProperty('total', 5.91);
+    expect(newOrder.items[0].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -13.2
+    );
+    expect(newOrder.items[0].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      5.797
+    );
+
+    expect(newOrder.items[1].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -2.2425
+    );
+    expect(newOrder.items[1].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0.98483125
+    );
+
+    expect(newOrder.items[2].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -0.9675
+    );
+    expect(newOrder.items[2].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0.42489375
+    );
+  });
+
+  test('CU-861n7pum9 - Get calculated Order, multiple items, 2 modifiers: 1 item discount (sort 1), 1 order tax (sort 99)', () => {
+    const taxMod = {
+      _id: 2,
+      name: `7.75% tax`,
+      type: 'tax',
+      compute: {
+        amount: 7.75,
+        type: 'percentage',
+        action: 'add',
+      },
+      properties: {
+        sort: 99,
+      },
+    };
+
+    const discountMod = {
+      _id: 1,
+      compute: {
+        amount: 15,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: `15% Discount`,
+      type: 'discount',
+      properties: {
+        sort: 1,
+      },
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 44,
+      quantity: 2,
+      modifiers: [discountMod],
+    };
+    const item2 = {
+      _id: 2,
+      price: 14.95,
+      quantity: 1,
+      modifiers: [discountMod],
+    };
+    const item3 = {
+      _id: 3,
+      price: 2.15,
+      quantity: 3,
+      modifiers: [discountMod],
+    };
+
+    const order = {
+      items: [item1, item2, item3],
+      modifiers: [taxMod],
+    };
+
+    const newOrder = pricingService.order.calculate(order);
+
+    expect(newOrder).toHaveProperty('total', 100.2);
+    expect(newOrder).toHaveProperty('subTotal', 109.4);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -16.41,
+      tax: 7.21,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 80.6);
+    expect(newOrder.items[1]).toHaveProperty('total', 13.7);
+    expect(newOrder.items[2]).toHaveProperty('total', 5.9);
+    expect(newOrder.items[0].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -13.2
+    );
+    expect(newOrder.items[0].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      5.8
+    );
+
+    expect(newOrder.items[1].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -2.2425
+    );
+    expect(newOrder.items[1].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0.99
+    );
+
+    expect(newOrder.items[2].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -0.9675
+    );
+    expect(newOrder.items[2].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0.42
+    );
+  });
+
+  test('CU-861n7pum9 - Get calculated Order, multiple items, 2 modifiers: 1 item discount (ignoreQty), 1 order tax', () => {
+    const taxMod = {
+      _id: 2,
+      name: `7.75% tax`,
+      type: 'tax',
+      compute: {
+        amount: 7.75,
+        type: 'percentage',
+        action: 'add',
+      },
+    };
+
+    const discountMod = {
+      _id: 1,
+      compute: {
+        amount: 1,
+        type: 'fixed',
+        action: 'subtract',
+      },
+      name: `1 USD`,
+      type: 'fixed',
+      properties: {
+        ignoreQuantity: true,
+      },
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 1,
+      quantity: 1,
+      modifiers: [discountMod],
+    };
+    const item2 = {
+      _id: 2,
+      price: 1,
+      quantity: 1,
+      modifiers: [discountMod],
+    };
+    const item3 = {
+      _id: 3,
+      price: 0.5,
+      quantity: 2,
+      modifiers: [discountMod],
+    };
+
+    const order = {
+      items: [item1, item2, item3],
+      modifiers: [taxMod],
+    };
+
+    const newOrder = pricingService.order.calculate(order);
+
+    expect(newOrder).toHaveProperty('total', 0);
+    expect(newOrder).toHaveProperty('subTotal', 3);
+    expect(newOrder).toHaveProperty('subTotals', {
+      fixed: -3,
+      tax: 0,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 0);
+    expect(newOrder.items[1]).toHaveProperty('total', 0);
+    expect(newOrder.items[2]).toHaveProperty('total', 0);
+    expect(newOrder.items[0].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -1
+    );
+    expect(newOrder.items[0].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0
+    );
+
+    expect(newOrder.items[1].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -1
+    );
+    expect(newOrder.items[1].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0
+    );
+
+    expect(newOrder.items[2].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -1
+    );
+    expect(newOrder.items[2].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0
+    );
+  });
+
+  test('CU-861n7pum9 - Get calculated Order, multiple items, 2 modifiers: 1 order discount (sort 1), 1 order tax (sort 2)', () => {
+    const taxMod = {
+      _id: 2,
+      name: `7.75% tax`,
+      type: 'tax',
+      compute: {
+        amount: 7.75,
+        type: 'percentage',
+        action: 'add',
+      },
+      properties: {
+        sort: 2,
+      },
+    };
+
+    const discountMod = {
+      _id: 1,
+      compute: {
+        amount: 1,
+        type: 'fixed',
+        action: 'subtract',
+      },
+      name: `1 USD`,
+      type: 'fixed',
+      properties: {
+        sort: 1,
+      },
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 1,
+      quantity: 1,
+      modifiers: [],
+    };
+    const item2 = {
+      _id: 2,
+      price: 1,
+      quantity: 1,
+      modifiers: [],
+    };
+    const item3 = {
+      _id: 3,
+      price: 0.5,
+      quantity: 2,
+      modifiers: [],
+    };
+
+    const order = {
+      items: [item1, item2, item3],
+      modifiers: [taxMod, discountMod],
+    };
+
+    const newOrder = pricingService.order.calculate(order);
+
+    expect(newOrder).toHaveProperty('total', 2.15);
+    expect(newOrder).toHaveProperty('subTotal', 3);
+    expect(newOrder).toHaveProperty('subTotals', {
+      fixed: -1,
+      tax: 0.15,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 0.72);
+    expect(newOrder.items[1]).toHaveProperty('total', 0.72);
+    expect(newOrder.items[2]).toHaveProperty('total', 0.71);
+    expect(newOrder.items[0].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -0.33
+    );
+    expect(newOrder.items[0].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0.05
+    );
+
+    expect(newOrder.items[1].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -0.33
+    );
+    expect(newOrder.items[1].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0.05
+    );
+
+    expect(newOrder.items[2].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -0.17
+    );
+    expect(newOrder.items[2].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0.05
+    );
+  });
+
+  test('CU-861n7pum9 - Get calculated Order, multiple items, 2 modifiers: 1 item discount, 1 order tax', () => {
+    const taxMod = {
+      _id: 2,
+      name: `7.75% tax`,
+      type: 'tax',
+      compute: {
+        amount: 7.75,
+        type: 'percentage',
+        action: 'add',
+      },
+    };
+
+    const discountMod = {
+      _id: 1,
+      compute: {
+        amount: 1,
+        type: 'fixed',
+        action: 'subtract',
+      },
+      name: `1 USD`,
+      type: 'fixed',
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 1,
+      quantity: 1,
+      modifiers: [discountMod],
+    };
+    const item2 = {
+      _id: 2,
+      price: 1,
+      quantity: 1,
+      modifiers: [discountMod],
+    };
+    const item3 = {
+      _id: 3,
+      price: 0.5,
+      quantity: 2,
+      modifiers: [discountMod],
+    };
+
+    const order = {
+      items: [item1, item2, item3],
+      modifiers: [taxMod],
+    };
+
+    const newOrder = pricingService.order.calculate(order);
+
+    expect(newOrder).toHaveProperty('total', 0);
+    expect(newOrder).toHaveProperty('subTotal', 3);
+    expect(newOrder).toHaveProperty('subTotals', {
+      fixed: -3,
+      tax: 0,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 0);
+    expect(newOrder.items[1]).toHaveProperty('total', 0);
+    expect(newOrder.items[2]).toHaveProperty('total', 0);
+    expect(newOrder.items[0].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -1
+    );
+    expect(newOrder.items[0].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0
+    );
+
+    expect(newOrder.items[1].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -1
+    );
+    expect(newOrder.items[1].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0
+    );
+
+    expect(newOrder.items[2].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -1
+    );
+    expect(newOrder.items[2].modifiers[1]._computed).toHaveProperty(
+      'amount',
+      0
+    );
+  });
+
   test('CU-3und87h : Calculate order with 20 USD credit', () => {
     const newOrder = pricingService.order.calculate(orderCredit);
 
     const [item1, item2, item3] = newOrder.items;
     expect(newOrder).toHaveProperty('total', 12.5);
-    expect(item1).toHaveProperty('total', 3.64);
-    expect(item1.modifiers[1].compute).toHaveProperty('amount', 5.86);
+    expect(item1).toHaveProperty('total', 3.66);
+    expect(item1.modifiers[1].compute).toHaveProperty('amount', 5.84);
 
-    expect(item2).toHaveProperty('total', 5.39);
-    expect(item2.modifiers[1].compute).toHaveProperty('amount', 8.61);
+    expect(item2).toHaveProperty('total', 5.38);
+    expect(item2.modifiers[1].compute).toHaveProperty('amount', 8.62);
 
-    expect(item3).toHaveProperty('total', 3.47);
-    expect(item3.modifiers[1].compute).toHaveProperty('amount', 5.53);
+    expect(item3).toHaveProperty('total', 3.46);
+    expect(item3.modifiers[1].compute).toHaveProperty('amount', 5.54);
   });
 
   test('Auto split a Parent Order', () => {
@@ -992,6 +1621,7 @@ describe('Order actions', () => {
       modifiers: paymentModifiers,
       order,
     });
+
     const newOrder = pricingService.order.calculate(order);
 
     expect(newOrder).toHaveProperty('total', 36.45);
@@ -1000,9 +1630,9 @@ describe('Order actions', () => {
       discount: -10,
       fee: 4,
     });
-    expect(newOrder.items[0]).toHaveProperty('total', 8.06);
-    expect(newOrder.items[1]).toHaveProperty('total', 7.71);
-    expect(newOrder.items[2]).toHaveProperty('total', 11.37);
-    expect(newOrder.items[3]).toHaveProperty('total', 9.31);
+    expect(newOrder.items[0]).toHaveProperty('total', 8.09);
+    expect(newOrder.items[1]).toHaveProperty('total', 7.7);
+    expect(newOrder.items[2]).toHaveProperty('total', 11.36);
+    expect(newOrder.items[3]).toHaveProperty('total', 9.3);
   });
 });

package/lib/item/addIndirectModifier.js

@@ -25,7 +25,9 @@ module.exports = ({ utils, modifierActions }) => {
       );
     }, 0);
 
-    // check validation
+    if (modifier.compute.type === 'percentage' && modifier.type !== 'credit')
+      return itemsModifiers;
+
     if (math.abs(totalDistributed) !== math.abs(orderModifierTotal)) {
       const difference = math.sub(orderModifierTotal, totalDistributed);
       const selectedItem = items.find(

package/lib/item/calculate.js

@@ -66,14 +66,22 @@ module.exports = ({ _, utils, modifierActions }) => {
 
         modifiers.push(_modifier);
         const { type, _computed } = _modifier;
-        let computedAmount = modifierActions.isIgnoreQuantity(_modifier)
-          ? _computed.amount
-          : math.mul(_computed.amount, quantity);
+
+        const computedAmountCalc = math.mul(_computed.amount, quantity);
+        const computedPriceCalc = math.mul(computedPrice * quantity);
+
+        let computedAmount =
+          _modifier.compute.type === 'percentage' ||
+          modifierActions.isIgnoreQuantity(_modifier) ||
+          math.gt(math.abs(computedAmountCalc), computedPriceCalc)
+            ? _computed.amount
+            : computedAmountCalc;
+
         // subscription modifiers have fixed amount and can't be multiplied by quantity
         if (modifierActions.isSubscription(_modifier))
           computedAmount = _computed.amount;
 
-        prvPrice = math.add(prvPrice, computedAmount);
+        prvPrice = math.add(prvPrice, math.div(_computed.amount, quantity));
         prvSort = sort;
 
         if (included) {
@@ -90,7 +98,9 @@ module.exports = ({ _, utils, modifierActions }) => {
 
     subTotals._actual = math.add(subTotals._simple, subTotals._included);
 
-    const total = math.add(subTotals._actual, subTotals._xincluded);
+    const total = math.toDecimalPlaces(
+      math.add(subTotals._actual, subTotals._xincluded)
+    );
 
     return {
       ...item,

package/lib/item/getTotals.js

@@ -16,15 +16,17 @@ module.exports = ({ utils }) => {
       }
     }
 
-    const total = Object.keys(subTotals).reduce(
-      (acc, key) => math.add(acc, subTotals[key]),
-      subTotal
+    const total = math.toDecimalPlaces(
+      Object.keys(subTotals).reduce(
+        (acc, key) => math.add(acc, subTotals[key]),
+        subTotal
+      )
     );
 
     subTotals = Object.keys(subTotals).reduce(
       (acc, key) => ({
         ...acc,
-        [key]: subTotals[key],
+        [key]: math.toDecimalPlaces(subTotals[key]),
       }),
       {}
     );

package/lib/modifier/calculate.js

@@ -1,13 +1,13 @@
 /**
  * Get calculated modifier
  */
- module.exports = ({ _, constants, utils, localization, actions }) => {
+module.exports = ({ _, constants, utils, localization, actions }) => {
   const { math } = utils;
   const { Modifier } = constants;
 
   return function calculate(
     modifier = {},
-    options = { price: 0, skip: false }
+    options = { price: 0, quantity: 0, skip: false }
   ) {
     const { name, compute } = modifier;
     const { type, action, amount = 0 } = compute || {};
@@ -15,8 +15,16 @@
       amount: 0,
       description: '',
     };
-    const maxAmount = actions.getProperty(modifier, 'maxAmount');
+
+    const maxAmountProp = actions.getProperty(modifier, 'maxAmount');
+
     if (!options.skip) {
+      const maxAmountCalc = math.mul(options.price, options.quantity);
+
+      const maxAmount = maxAmountProp
+        ? math.min(maxAmountProp, maxAmountCalc)
+        : maxAmountCalc;
+
       const multiplier = action === Modifier.Compute.Actions.SUBTRACT ? -1 : 1;
 
       if (type === Modifier.Compute.Types.FIXED)
@@ -24,15 +32,16 @@
 
       if (type === Modifier.Compute.Types.PERCENTAGE)
         _computed.amount = math.div(
-          math.mul(multiplier, options.price, amount),
+          math.mul(multiplier, options.price, options.quantity, amount),
           100
         );
 
       if (!type || action === Modifier.Compute.Actions.OVERRIDE)
         _computed.amount = 0;
 
-      if (maxAmount && math.gt(math.abs(_computed.amount), maxAmount))
-        _computed.amount = maxAmount;
+      if (math.gt(math.abs(_computed.amount), maxAmount)) {
+        _computed.amount = maxAmount * multiplier;
+      }
     }
 
     const localAmount = localization.formatAmount(_computed.amount);

package/lib/modifier/createIndirectModifier.js

@@ -16,9 +16,14 @@ module.exports = ({ _, utils, constants, actions }) => {
     let modifierAmount = amount;
 
     if (type === Modifier.Compute.Types.PERCENTAGE) {
-      const modifierAmountByPercentage = math.div(
-        math.mul(options.orderTotal, amount),
-        100
+      const modifierAmountByPercentage = math.toDecimalPlaces(
+        math.div(
+          math.mul(
+            modifier.type === 'credit' ? options.orderTotal : options.itemTotal,
+            amount
+          ),
+          100
+        )
       );
       modifierAmount =
         maxAmount !== null && modifierAmountByPercentage > maxAmount
@@ -26,14 +31,20 @@ module.exports = ({ _, utils, constants, actions }) => {
           : modifierAmountByPercentage;
     }
 
-    let amountToApply = 0;
+    let amountToApply = modifierAmount;
 
-    if (!math.isZero(options.orderTotal))
-      amountToApply = math.div(
-        math.mul(modifierAmount, options.itemTotal),
-        options.orderTotal,
-        options.itemQuantity
+    if (
+      !math.isZero(options.orderTotal) &&
+      (type !== Modifier.Compute.Types.PERCENTAGE || modifier.type === 'credit')
+    ) {
+      amountToApply = math.toDecimalPlaces(
+        math.div(
+          math.mul(modifierAmount, options.itemTotal),
+          options.orderTotal,
+          options.itemQuantity
+        )
       );
+    }
 
     const modifierToAdd = actions.create({
       ..._.cloneDeep(modifier),
@@ -43,6 +54,12 @@ module.exports = ({ _, utils, constants, actions }) => {
         amount: amountToApply,
         action: compute.action || Modifier.Compute.Actions.SUBTRACT,
       },
+      properties: {
+        ignoreQuantity:
+          (modifier.properties && modifier.properties.ignoreQuantity) ||
+          type === Modifier.Compute.Types.PERCENTAGE,
+        ...(modifier.properties || {}),
+      },
     });
     if (maxAmount !== null) delete modifierToAdd.properties.maxAmount;
 

package/lib/modifier/getSplittedModifiers.js

@@ -7,9 +7,11 @@ module.exports = ({ utils }) => {
     totalSplitedOrder,
   }) =>
     totalOriginOrder
-      ? math.div(
-          math.mul(modifierAmount, totalSplitedOrder || 0),
-          totalOriginOrder
+      ? math.toDecimalPlaces(
+          math.div(
+            math.mul(modifierAmount, totalSplitedOrder || 0),
+            totalOriginOrder
+          )
         )
       : 0;
 

package/lib/order/getTotals.js

@@ -17,6 +17,7 @@ module.exports = ({ utils }) => {
                 orderSubTotals[key]
               );
           }
+
           return {
             total: math.add(acc.total, order.total),
             subTotals,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.22",
+  "version": "1.0.23",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -19,7 +19,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@darkpos/utils": "1.0.8",
+    "@darkpos/utils": "1.0.9",
     "lodash": "^4.17.21",
     "moment-timezone": "^0.5.34"
   },
@@ -36,5 +36,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "82cfaf282b53da5c4343a36daad7e7d16fe4aa2c"
+  "gitHead": "6648705882ec8351463ba823c213cf7c198129ce"
 }