@darkpos/pricing 1.0.53 → 1.0.54

package/__TEST__/item/addIndirectModifier.test.js

@@ -71,7 +71,7 @@ describe('addIndirectModifier Function', () => {
     expect(result).toEqual({
       item1: {
         compute: { amount: 50 }, // Adjusted amount to fix the total distribution difference
-        properties: { ignoreQuantity: true },
+        properties: { isQuantityMultiplier: false },
       },
       item2: { compute: { amount: 50 }, properties: {} },
     });
@@ -127,7 +127,7 @@ describe('addIndirectModifier Function', () => {
       item1: {
         compute: { amount: -35 },
         properties: {
-          ignoreQuantity: true,
+          isQuantityMultiplier: false,
         },
         _computed: { amount: 15 },
       },
@@ -160,7 +160,7 @@ describe('addIndirectModifier Function', () => {
       item1: {
         compute: { amount: -30 },
         properties: {
-          ignoreQuantity: true,
+          isQuantityMultiplier: false,
         },
       },
       item2: { compute: { amount: 50 }, properties: {} },

package/__TEST__/item.test.js

@@ -15,6 +15,9 @@ describe('Item actions', () => {
         type: 'discount',
         direct: false,
         included: false,
+        properties: {
+          isQuantityMultiplier: true,
+        },
       },
       {
         compute: {
@@ -26,6 +29,9 @@ describe('Item actions', () => {
         type: 'discount',
         direct: false,
         included: false,
+        properties: {
+          isQuantityMultiplier: true,
+        },
       },
       {
         compute: {
@@ -37,6 +43,9 @@ describe('Item actions', () => {
         type: 'discount',
         direct: false,
         included: false,
+        properties: {
+          isQuantityMultiplier: true,
+        },
       },
     ];
     const orderItem = { price: 30, quantity: 2, modifiers };
@@ -60,6 +69,9 @@ describe('Item actions', () => {
         name: 'modifier1',
         direct: true,
         included: false,
+        properties: {
+          isQuantityMultiplier: true,
+        },
       },
       {
         compute: {
@@ -71,6 +83,9 @@ describe('Item actions', () => {
         type: 'discount',
         direct: true,
         included: false,
+        properties: {
+          isQuantityMultiplier: true,
+        },
       },
       {
         compute: {
@@ -82,6 +97,9 @@ describe('Item actions', () => {
         type: 'tax',
         direct: true,
         included: false,
+        properties: {
+          isQuantityMultiplier: true,
+        },
       },
     ];
     const orderItem = { price: 30, quantity: 2, modifiers };
@@ -110,6 +128,9 @@ describe('Item actions', () => {
         type: 'discount',
         direct: true,
         included: true,
+        properties: {
+          isQuantityMultiplier: true,
+        },
       },
       {
         compute: {
@@ -121,6 +142,9 @@ describe('Item actions', () => {
         type: 'discount',
         direct: true,
         included: true,
+        properties: {
+          isQuantityMultiplier: true,
+        },
       },
       {
         compute: {
@@ -132,6 +156,9 @@ describe('Item actions', () => {
         type: 'upcharge',
         direct: true,
         included: true,
+        properties: {
+          isQuantityMultiplier: true,
+        },
       },
     ];
     const orderItem = { price: 30, quantity: 2, modifiers };
@@ -631,7 +658,7 @@ describe('Item actions', () => {
     expect(newItem).toHaveProperty('total', 70.5);
     expect(newItem).toHaveProperty('price', 13.5);
     expect(newItem.modifiers[0]).toHaveProperty('_computed', {
-      amount: 10,
+      amount: 30,
       description: 'Override modamount fixed 10 ($30.00)',
     });
 

package/__TEST__/mocks/addItemMock.js

@@ -1672,7 +1672,7 @@ const addItemMock = {
             items: [],
           },
           sort: null,
-          ignoreQuantity: true,
+          isQuantityMultiplier: false,
         },
         _computed: null,
         addModifiers: [],
@@ -1795,7 +1795,7 @@ const addItemMock = {
           },
           department: {},
           sort: null,
-          ignoreQuantity: false,
+          isQuantityMultiplier: true,
         },
         _computed: null,
         addModifiers: [],

package/__TEST__/mocks/order-credit.json

@@ -262,7 +262,7 @@
                     },
                     "properties": {
                         "sort": 999,
-                        "ignoreQuantity": true
+                        "isQuantityMultiplier": false
                     },
                     "_id": "63ade222dd19604ca368eb29",
                     "modifierId": "63ade212dd19604ca368eb23",

package/__TEST__/mocks/partially-paid/order-partially-paid.json

@@ -96,7 +96,7 @@
           "default": false,
           "code": "",
           "properties": {
-            "ignoreQuantity": true
+            "isQuantityMultiplier": false
           },
           "_computed": {
             "amount": -2.36,
@@ -149,7 +149,7 @@
           "default": false,
           "code": "",
           "properties": {
-            "ignoreQuantity": true
+            "isQuantityMultiplier": false
           },
           "_computed": {
             "amount": 0.48,

package/__TEST__/mocks/unpaid/order-not-paid.json

@@ -98,7 +98,7 @@
                     "default": false,
                     "code": "",
                     "properties": {
-                        "ignoreQuantity": true
+                        "isQuantityMultiplier": false
                     },
                     "_computed": {
                         "amount": -2.36,

package/__TEST__/modifier/createIndirectModifier.test.js

@@ -1,38 +1,14 @@
-const _ = require('lodash');
-const utils = require('@darkpos/utils');
-const createIndirectModifierFunction = require('../../lib/modifier/createIndirectModifier');
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
 
 describe('createIndirectModifier Function', () => {
   test('create indirect modifier with an undefined modifier compute', () => {
-    const constants = {
-      Modifier: {
-        Compute: {
-          Types: {
-            PERCENTAGE: 'percentage',
-            FIXED: 'fixed',
-          },
-          Actions: {
-            SUBTRACT: 'subtract',
-          },
-        },
-      },
-    };
-    const actions = {
-      getProperty: (modifier, prop) => modifier[prop],
-      create: modifier => modifier,
-    };
-    // const getComputeModField = jest.fn().mockReturnValue(null);
-
-    const createIndirectModifier = createIndirectModifierFunction({
-      _,
-      utils,
-      constants,
-      actions,
-    });
-
     const modifier = {
       type: 'credit',
-      properties: {},
+      properties: {
+        isQuantityMultiplier: true,
+      },
     };
     const options = {
       orderTotal: 100,
@@ -40,9 +16,12 @@ describe('createIndirectModifier Function', () => {
       itemTotal: 50,
     };
 
-    const result = createIndirectModifier(modifier, options);
+    const result = pricingService.modifier.createIndirectModifier(
+      modifier,
+      options
+    );
 
-    expect(result).toEqual({
+    expect(result).toMatchObject({
       ...modifier,
       direct: false,
       compute: {
@@ -51,39 +30,14 @@ describe('createIndirectModifier Function', () => {
         action: 'subtract',
       },
       properties: {
-        ignoreQuantity: false,
+        isQuantityMultiplier: true,
       },
     });
   });
   test('create indirect modifier with a null modifier compute', () => {
-    const constants = {
-      Modifier: {
-        Compute: {
-          Types: {
-            PERCENTAGE: 'percentage',
-            FIXED: 'fixed',
-          },
-          Actions: {
-            SUBTRACT: 'subtract',
-          },
-        },
-      },
-    };
-    const actions = {
-      getProperty: (modifier, prop) => modifier[prop],
-      create: modifier => modifier,
-    };
-
-    const createIndirectModifier = createIndirectModifierFunction({
-      _,
-      utils,
-      constants,
-      actions,
-    });
-
     const modifier = {
       type: 'credit',
-      properties: {},
+      properties: { isQuantityMultiplier: true },
       compute: null,
     };
     const options = {
@@ -92,9 +46,12 @@ describe('createIndirectModifier Function', () => {
       itemTotal: 50,
     };
 
-    const result = createIndirectModifier(modifier, options);
+    const result = pricingService.modifier.createIndirectModifier(
+      modifier,
+      options
+    );
 
-    expect(result).toEqual({
+    expect(result).toMatchObject({
       ...modifier,
       direct: false,
       compute: {
@@ -103,39 +60,14 @@ describe('createIndirectModifier Function', () => {
         action: 'subtract',
       },
       properties: {
-        ignoreQuantity: false,
+        isQuantityMultiplier: true,
       },
     });
   });
   test('create indirect modifier regular modifier', () => {
-    const constants = {
-      Modifier: {
-        Compute: {
-          Types: {
-            PERCENTAGE: 'percentage',
-            FIXED: 'fixed',
-          },
-          Actions: {
-            SUBTRACT: 'subtract',
-          },
-        },
-      },
-    };
-    const actions = {
-      getProperty: (modifier, prop) => modifier[prop],
-      create: modifier => modifier,
-    };
-
-    const createIndirectModifier = createIndirectModifierFunction({
-      _,
-      utils,
-      constants,
-      actions,
-    });
-
     const modifier = {
       type: 'credit',
-      properties: {},
+      properties: { isQuantityMultiplier: true },
       compute: {
         type: 'fixed',
         action: 'add',
@@ -148,9 +80,12 @@ describe('createIndirectModifier Function', () => {
       itemTotal: 50,
     };
 
-    const result = createIndirectModifier(modifier, options);
+    const result = pricingService.modifier.createIndirectModifier(
+      modifier,
+      options
+    );
 
-    expect(result).toEqual({
+    expect(result).toMatchObject({
       ...modifier,
       direct: false,
       compute: {
@@ -159,7 +94,7 @@ describe('createIndirectModifier Function', () => {
         amount: 2.5,
       },
       properties: {
-        ignoreQuantity: false,
+        isQuantityMultiplier: true,
       },
     });
   });

package/__TEST__/modifier/hasModifier.test.js

@@ -1485,7 +1485,7 @@ describe('hasModifier Function', () => {
             action: 'subtract',
           },
           properties: {
-            ignoreQuantity: false,
+            isQuantityMultiplier: true,
           },
           _id: '67226d7fe779680a203df892',
           modifierId: '62cdbfd01ee1b4001932822e',
@@ -1531,7 +1531,7 @@ describe('hasModifier Function', () => {
             action: 'subtract',
           },
           properties: {
-            ignoreQuantity: false,
+            isQuantityMultiplier: true,
             subscription: {},
             override: {},
             group: {

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

@@ -806,7 +806,7 @@ describe('Order actions', () => {
               default: false,
               code: 'L',
               properties: {
-                ignoreQuantity: false,
+                isQuantityMultiplier: true,
               },
               _computed: {
                 amount: 0,
@@ -848,7 +848,7 @@ describe('Order actions', () => {
               default: false,
               code: '',
               properties: {
-                ignoreQuantity: false,
+                isQuantityMultiplier: true,
                 group: {
                   modifiers: [],
                   items: [],

package/__TEST__/order/order.test.js

@@ -21,6 +21,9 @@ describe('Order actions', () => {
         },
         name: 'modifier1',
         type: 'discount',
+        properties: {
+          isQuantityMultiplier: true,
+        },
       },
       {
         compute: {
@@ -30,11 +33,17 @@ describe('Order actions', () => {
         },
         name: 'modifier2',
         type: 'discount',
+        properties: {
+          isQuantityMultiplier: true,
+        },
       },
       {
         compute: { amount: 2, type: 'fixed', action: 'subtract' },
         name: 'modifier3',
         type: 'discount',
+        properties: {
+          isQuantityMultiplier: true,
+        },
       },
     ];
     const orderItem = { price: 30, quantity: 2, modifiers };
@@ -61,6 +70,9 @@ describe('Order actions', () => {
           },
           name: 'modifier1',
           type: 'discount',
+          properties: {
+            isQuantityMultiplier: true,
+          },
         },
       ],
     };
@@ -107,6 +119,9 @@ describe('Order actions', () => {
       },
       name: 'modifier1',
       type: 'discount',
+      properties: {
+        isQuantityMultiplier: true,
+      },
     };
 
     const order = { items: [item1, item2], modifiers: [modifier1] };
@@ -720,6 +735,7 @@ describe('Order actions', () => {
       },
       properties: {
         sort: 99,
+        isQuantityMultiplier: true,
       },
     };
 
@@ -734,6 +750,7 @@ describe('Order actions', () => {
       type: 'discount',
       properties: {
         sort: 1,
+        isQuantityMultiplier: true,
       },
     };
 
@@ -812,6 +829,7 @@ describe('Order actions', () => {
       },
       properties: {
         sort: 99,
+        isQuantityMultiplier: true,
       },
     };
 
@@ -826,6 +844,7 @@ describe('Order actions', () => {
       type: 'discount',
       properties: {
         sort: 1,
+        isQuantityMultiplier: true,
       },
     };
 
@@ -904,6 +923,7 @@ describe('Order actions', () => {
       },
       properties: {
         sort: 99,
+        isQuantityMultiplier: true,
       },
     };
 
@@ -918,6 +938,7 @@ describe('Order actions', () => {
       type: 'discount',
       properties: {
         sort: 1,
+        isQuantityMultiplier: true,
       },
     };
 
@@ -1006,7 +1027,7 @@ describe('Order actions', () => {
       name: `1 USD`,
       type: 'fixed',
       properties: {
-        ignoreQuantity: true,
+        isQuantityMultiplier: false,
       },
     };
 
@@ -1085,6 +1106,7 @@ describe('Order actions', () => {
       },
       properties: {
         sort: 2,
+        isQuantityMultiplier: true,
       },
     };
 
@@ -1099,6 +1121,7 @@ describe('Order actions', () => {
       type: 'fixed',
       properties: {
         sort: 1,
+        isQuantityMultiplier: true,
       },
     };
 
@@ -1157,7 +1180,7 @@ describe('Order actions', () => {
 
     expect(newOrder.items[2].modifiers[0]._computed).toHaveProperty(
       'amount',
-      -0.16666666666666666
+      -0.3333333333333333
     );
     expect(newOrder.items[2].modifiers[1]._computed).toHaveProperty(
       'amount',
@@ -1871,6 +1894,7 @@ describe('Order actions', () => {
       },
       properties: {
         sort: 2,
+        isQuantityMultiplier: true,
       },
     };
 
@@ -1885,6 +1909,7 @@ describe('Order actions', () => {
       type: 'percentage',
       properties: {
         sort: 1,
+        isQuantityMultiplier: true,
       },
     };
 
@@ -2087,7 +2112,7 @@ describe('Order actions', () => {
     expect(newOrderFixedModifier).toHaveProperty('total', 20);
   });
 
-  test('CU-86dtxh2y5: #2.A- Get calculated Order, One item and fixed Fee Modifier (ignoreQuantity: false)', () => {
+  test('CU-86dtxh2y5: #2.A- Get calculated Order, One item and fixed Fee Modifier (isQuantityMultiplier: true)', () => {
     const newOrderFixedModifier = pricingService.order.calculate({
       items: [
         {
@@ -2103,6 +2128,9 @@ describe('Order actions', () => {
               },
               name: 'fee 20 USD',
               type: 'fee',
+              properties: {
+                isQuantityMultiplier: true,
+              },
             },
           ],
         },
@@ -2111,7 +2139,7 @@ describe('Order actions', () => {
     expect(newOrderFixedModifier).toHaveProperty('total', 50);
   });
 
-  test('CU-86dtxh2y5: #2.B- Get calculated Order, One item and fixed Fee Modifier (ignoreQuantity: true)', () => {
+  test('CU-86dtxh2y5: #2.B- Get calculated Order, One item and fixed Fee Modifier (isQuantityMultiplier: false)', () => {
     const newOrderFixedModifier = pricingService.order.calculate({
       items: [
         {
@@ -2128,7 +2156,7 @@ describe('Order actions', () => {
               name: 'fee 20 USD',
               type: 'fee',
               properties: {
-                ignoreQuantity: true,
+                isQuantityMultiplier: false,
               },
             },
           ],
@@ -2158,7 +2186,7 @@ describe('Order actions', () => {
     expect(newOrderFixedModifier).toHaveProperty('total', 120);
   });
 
-  test('CU-86dtxh2y5: #4- Get calculated Order, One item and fixed Fee Modifier, using createFeeModifier (ignoreQuantity: true)', () => {
+  test('CU-86dtxh2y5: #4- Get calculated Order, One item and fixed Fee Modifier, using createFeeModifier (isQuantityMultiplier: false)', () => {
     const newOrderFixedModifier = pricingService.order.calculate({
       items: [
         {
@@ -2172,7 +2200,7 @@ describe('Order actions', () => {
           amount: 100,
           type: Types.FIXED,
           properties: {
-            ignoreQuantity: true,
+            isQuantityMultiplier: false,
           },
         }),
       ],
@@ -2661,4 +2689,421 @@ describe('Order actions', () => {
       _actual: 4.65,
     });
   });
+  test('CU-861n7pum9 - Calculate order -> discountMod percentage isIgnoreQuanity=true qt=1', () => {
+    const discountMod = {
+      _id: 1,
+      compute: {
+        amount: 50,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: `50% discount`,
+      type: 'discount',
+      properties: {
+        isQuantityMultiplier: false,
+      },
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 10,
+      quantity: 1,
+      modifiers: [discountMod],
+    };
+
+    const order = {
+      items: [item1],
+    };
+
+    const newOrder = pricingService.order.calculate(order);
+
+    expect(newOrder).toHaveProperty('total', 5);
+    expect(newOrder).toHaveProperty('subTotal', 10);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -5,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 5);
+    expect(newOrder.items[0].modifiers[0]._computed).toHaveProperty(
+      'amount',
+      -5
+    );
+  });
+
+  test('CU-861n7pum9 - Calculate order -> discountMod percentage isIgnoreQuanity=true qt=2', () => {
+    const discountMod = {
+      _id: 1,
+      compute: {
+        amount: 50,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: `50% discount`,
+      type: 'discount',
+      properties: {
+        isQuantityMultiplier: false,
+      },
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 10,
+      quantity: 2,
+      modifiers: [discountMod],
+    };
+
+    const order = {
+      items: [item1],
+    };
+
+    const newOrder = pricingService.order.calculate(order);
+
+    expect(newOrder).toHaveProperty('total', 15);
+    expect(newOrder).toHaveProperty('subTotal', 20);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -5,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 15);
+    expect(newOrder.items[0].modifiers[0]).toHaveProperty('_computed', {
+      amount: -5,
+      description: '50% discount (-$5.00)',
+    });
+  });
+  test('CU-861n7pum9 - Calculate order -> discountMod100Fixed   qt=1', () => {
+    const discountMod100Fixed = {
+      _id: 1,
+      compute: {
+        amount: 100,
+        type: 'fixed',
+        action: 'subtract',
+      },
+      name: `100% discount`,
+      type: 'discount',
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 10,
+      quantity: 1,
+      modifiers: [discountMod100Fixed],
+    };
+
+    const calculatedItem = pricingService.item.calculate(item1);
+
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem).toHaveProperty('subTotals', {
+      _actual: 10,
+      _direct: 0,
+      _included: 0,
+      _simple: 10,
+      _xdirect: -10,
+      _xincluded: -10,
+      discount: -10,
+    });
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: -10,
+      description: '100% discount (-$10.00)',
+    });
+  });
+
+  test('CU-861n7pum9 - Calculate order -> discountMod100Fixed and discountMod100Percentage  qt=1', () => {
+    const discountMod100Fixed = {
+      _id: 1,
+      compute: {
+        amount: 100,
+        type: 'fixed',
+        action: 'subtract',
+      },
+      name: `100% discount`,
+      type: 'discount',
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 10,
+      quantity: 1,
+      modifiers: [discountMod100Fixed, discountMod100Fixed],
+    };
+
+    const calculatedItem = pricingService.item.calculate(item1);
+
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem).toHaveProperty('subTotals', {
+      _actual: 10,
+      _direct: 0,
+      _included: 0,
+      _simple: 10,
+      _xdirect: -10,
+      _xincluded: -10,
+      discount: -10,
+    });
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: -10,
+      description: '100% discount (-$10.00)',
+    });
+
+    expect(calculatedItem.modifiers[1]).toHaveProperty('_computed', {
+      amount: -0,
+      description: '100% discount',
+    });
+  });
+
+  test('CU-861n7pum9 - Calculate order -> discountMod100Fixed  qt=2', () => {
+    const discountMod100Fixed = {
+      _id: 1,
+      compute: {
+        amount: 100,
+        type: 'fixed',
+        action: 'subtract',
+      },
+      name: `100 USD discount`,
+      type: 'discount',
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 10,
+      quantity: 2,
+      modifiers: [discountMod100Fixed, discountMod100Fixed],
+    };
+
+    const calculatedItem = pricingService.item.calculate(item1);
+
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem).toHaveProperty('subTotals', {
+      _actual: 20,
+      _direct: 0,
+      _included: 0,
+      _simple: 20,
+      _xdirect: -20,
+      _xincluded: -20,
+      discount: -20,
+    });
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: -20,
+      description: '100 USD discount (-$20.00)',
+    });
+
+    expect(calculatedItem.modifiers[1]).toHaveProperty('_computed', {
+      amount: -0,
+      description: '100 USD discount',
+    });
+  });
+
+  test('CU-861n7pum9 - Calculate order -> discountMod100Percentage  qt=1', () => {
+    const discountMod100Percentage = {
+      _id: 1,
+      compute: {
+        amount: 100,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: `100% discount`,
+      type: 'discount',
+      properties: {
+        isQuantityMultiplier: true,
+      },
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 10,
+      quantity: 2,
+      modifiers: [discountMod100Percentage, discountMod100Percentage],
+    };
+
+    const calculatedItem = pricingService.item.calculate(item1);
+
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem).toHaveProperty('subTotals', {
+      _actual: 20,
+      _direct: 0,
+      _included: 0,
+      _simple: 20,
+      _xdirect: -20,
+      _xincluded: -20,
+      discount: -20,
+    });
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: -20,
+      description: '100% discount (-$20.00)',
+    });
+
+    expect(calculatedItem.modifiers[1]).toHaveProperty('_computed', {
+      amount: -0,
+      description: '100% discount',
+    });
+  });
+
+  test('CU-861n7pum9 - Calculate order -> discountMod100Percentage discountMod100Fixed  qt=2', () => {
+    const discountMod100Percentage = {
+      _id: 1,
+      compute: {
+        amount: 100,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: `100% discount`,
+      type: 'discount',
+      properties: {
+        isQuantityMultiplier: true,
+      },
+    };
+
+    const discountMod100Fixed = {
+      _id: 1,
+      compute: {
+        amount: 100,
+        type: 'fixed',
+        action: 'subtract',
+      },
+      name: `100 USD discount`,
+      type: 'discount',
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 10,
+      quantity: 2,
+      modifiers: [
+        discountMod100Percentage,
+        discountMod100Fixed,
+        discountMod100Percentage,
+        discountMod100Fixed,
+      ],
+    };
+
+    const calculatedItem = pricingService.item.calculate(item1);
+
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem).toHaveProperty('subTotals', {
+      _actual: 20,
+      _direct: 0,
+      _included: 0,
+      _simple: 20,
+      _xdirect: -20,
+      _xincluded: -20,
+      discount: -20,
+    });
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: -20,
+      description: '100% discount (-$20.00)',
+    });
+
+    expect(calculatedItem.modifiers[1]).toHaveProperty('_computed', {
+      amount: -0,
+      description: '100 USD discount',
+    });
+  });
+
+  test('CU-861n7pum9 - Calculate order -> discountMod60Percentage discountMod100Fixed, sort,  qt=2', () => {
+    const discountMod60Percentage = {
+      _id: 1,
+      compute: {
+        amount: 60,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: `60% discount`,
+      type: 'discount',
+      properties: {
+        sort: 3,
+        isQuantityMultiplier: true,
+      },
+    };
+
+    const discountMod100Fixed = {
+      _id: 1,
+      compute: {
+        amount: 100,
+        type: 'fixed',
+        action: 'subtract',
+      },
+      name: `100 USD discount`,
+      type: 'discount',
+      properties: {
+        sort: 4,
+      },
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 10,
+      quantity: 2,
+      modifiers: [discountMod60Percentage, discountMod100Fixed],
+    };
+
+    const calculatedItem = pricingService.item.calculate(item1);
+
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem).toHaveProperty('subTotals', {
+      _actual: 20,
+      _direct: 0,
+      _included: 0,
+      _simple: 20,
+      _xdirect: -20,
+      _xincluded: -20,
+      discount: -20,
+    });
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: -12,
+      description: '60% discount (-$12.00)',
+    });
+
+    expect(calculatedItem.modifiers[1]).toHaveProperty('_computed', {
+      amount: -8,
+      description: '100 USD discount (-$8.00)',
+    });
+  });
+
+  test('CU-861n7pum9 - Calculate order -> discountMod9Fixed , sort,  qt=2', () => {
+    const discountMod9Fixed = {
+      _id: 1,
+      compute: {
+        amount: 12,
+        type: 'fixed',
+        action: 'subtract',
+      },
+      name: `12 USD discount`,
+      type: 'discount',
+      properties: {
+        isQuantityMultiplier: true,
+      },
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 10,
+      quantity: 2,
+      modifiers: [discountMod9Fixed, discountMod9Fixed],
+    };
+
+    const calculatedItem = pricingService.item.calculate(item1);
+
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem).toHaveProperty('subTotals', {
+      _actual: 20,
+      _direct: 0,
+      _included: 0,
+      _simple: 20,
+      _xdirect: -20,
+      _xincluded: -20,
+      discount: -20,
+    });
+    expect(calculatedItem).toHaveProperty('total', 0);
+    expect(calculatedItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: -20,
+      description: '12 USD discount (-$20.00)',
+    });
+
+    expect(calculatedItem.modifiers[1]).toHaveProperty('_computed', {
+      amount: -0,
+      description: '12 USD discount',
+    });
+  });
 });

package/lib/item/addIndirectModifier.js

@@ -50,7 +50,7 @@ module.exports = ({ utils, modifierActions, _ }) => {
           },
           properties: {
             ...inheritedModifier.properties,
-            ignoreQuantity: true,
+            isQuantityMultiplier: false,
           },
         };
       }

package/lib/item/calculate.js

@@ -1,5 +1,3 @@
-const { getComputeModField } = require('../modifier/utils');
-
 /* eslint-disable no-restricted-syntax */
 module.exports = ({ _, utils, actions, modifierActions }) => {
   const { math } = utils;
@@ -94,6 +92,9 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         })
       );
 
+    let computedPrice = price;
+    let total = math.mul(computedPrice, quantity);
+
     if (modifiersToCompute.length || paymentModifiersToCompute.length) {
       // sort modifiers based on sort
       const sortedModifiers = modifierActions.sort([
@@ -101,7 +102,6 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         ...paymentModifiersToCompute,
       ]);
 
-      let computedPrice = price;
       let prvPrice = 0;
       let prvSort;
 
@@ -138,6 +138,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
             price: computedPrice,
             quantity,
             basePrice: actions.getBasePrice(item),
+            maxDiscountAmount: total,
           }
         );
 
@@ -150,29 +151,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
 
         const { type, _computed } = _modifier;
 
-        const computedAmountCalc = math.mul(_computed.amount, quantity);
-        const computedPriceCalc = math.mul(computedPrice * quantity);
-
-        // adding this computeField because now the compute from a modifier can be null
-        const computeField = getComputeModField(_modifier);
-
-        const isPercentage = computeField.type === 'percentage';
-        const isIgnoreQuantity = modifierActions.isIgnoreQuantity(_modifier);
-        const isNotFixedAddAndAmountGtPrice =
-          !modifierActions.isFixedAdd(_modifier) &&
-          math.gt(math.abs(computedAmountCalc), computedPriceCalc);
-
-        const isAmountOverrideAndNotMultiplier =
-          modifierActions.isAmountOverride(_modifier) &&
-          !modifierActions.isMultiplier(_modifier);
-
-        let computedAmount =
-          isPercentage ||
-          isIgnoreQuantity ||
-          isNotFixedAddAndAmountGtPrice ||
-          isAmountOverrideAndNotMultiplier
-            ? _computed.amount
-            : computedAmountCalc;
+        let computedAmount = _computed.amount;
 
         // subscription modifiers have fixed amount and can't be multiplied by quantity
         if (modifierActions.isSubscription(_modifier))
@@ -190,12 +169,15 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         if (direct)
           subTotals._direct = math.add(subTotals._direct, computedAmount);
         else subTotals._xdirect = math.add(subTotals._xdirect, computedAmount);
+
+        subTotals._actual = math.add(subTotals._simple, subTotals._included);
+        total = actions.getTotal({ subTotals });
       }
     }
 
     subTotals._actual = math.add(subTotals._simple, subTotals._included);
 
-    const total = actions.getTotal({ subTotals });
+    total = actions.getTotal({ subTotals });
 
     return {
       ...item,

package/lib/modifier/calculate.js

@@ -14,12 +14,14 @@ module.exports = ({ _, constants, utils, localization, actions }) => {
     const modifier = _modifier;
     const { name } = modifier;
     const compute = getComputeModField(modifier);
-    const { type, action, amount = 0 } = compute;
+    const { type, amount: computeAmount = 0 } = compute;
     const _computed = {
       amount: 0,
       description: '',
     };
 
+    const amount = computeAmount;
+
     const maxAmountProp = actions.getProperty(modifier, 'maxAmount');
 
     if (!options.skip) {
@@ -32,22 +34,41 @@ module.exports = ({ _, constants, utils, localization, actions }) => {
         ? math.min(maxAmountProp, maxAmountCalc)
         : maxAmountCalc;
 
-      const multiplier = action === Modifier.Compute.Actions.SUBTRACT ? -1 : 1;
+      const multiplier = actions.isSubtract(_modifier) ? -1 : 1;
 
-      if (type === Modifier.Compute.Types.FIXED)
+      if (type === Modifier.Compute.Types.FIXED) {
         _computed.amount = math.mul(multiplier, amount);
+      }
 
-      if (type === Modifier.Compute.Types.PERCENTAGE)
+      if (type === Modifier.Compute.Types.PERCENTAGE) {
         _computed.amount = math.div(
-          math.mul(multiplier, options.price, options.quantity, amount),
+          math.mul(multiplier, options.price, amount),
           100
         );
+      }
 
       if (!type) _computed.amount = 0;
 
       if (math.gt(math.abs(_computed.amount), maxAmount)) {
         _computed.amount = maxAmount * multiplier;
       }
+
+      if (
+        (!actions.isOverride(_modifier) &&
+          actions.isQuantityMultiplier(_modifier)) ||
+        (actions.isAmountOverride(_modifier) && actions.isMultiplier(_modifier))
+      ) {
+        _computed.amount = math.mul(_computed.amount, options.quantity);
+      }
+
+      if (
+        actions.isSubtract(_modifier) &&
+        typeof _computed.amount === 'number' &&
+        typeof options.maxDiscountAmount === 'number' &&
+        math.gt(math.abs(_computed.amount), options.maxDiscountAmount)
+      ) {
+        _computed.amount = math.mul(options.maxDiscountAmount, -1);
+      }
     }
 
     const localAmount =
@@ -71,7 +92,7 @@ module.exports = ({ _, constants, utils, localization, actions }) => {
 
     if (actions.isAmountOverride(modifier) && isMultiplier) {
       _computed.description = `${name} (${localization.formatAmount(
-        math.mul(_computed.amount, options.quantity)
+        _computed.amount
       )})`;
     }
 

package/lib/modifier/createFeeModifier.js

@@ -19,7 +19,7 @@ module.exports = ({ constants, actions, localization }) => {
       type: Modifier.Types.FEE,
       name: `${name} ${Modifier.Types.FEE}`,
       properties: {
-        ignoreQuantity: true,
+        isQuantityMultiplier: false,
         ...properties,
       },
       ...rest,

package/lib/modifier/createIndirectModifier.js

@@ -36,10 +36,9 @@ module.exports = ({ _, utils, constants, actions }) => {
       !math.isZero(options.orderTotal) &&
       (type !== Modifier.Compute.Types.PERCENTAGE || modifier.type === 'credit')
     ) {
-      const modififierQuantity =
-        modifier.properties && modifier.properties.ignoreQuantity
-          ? 1
-          : options.itemQuantity;
+      const modififierQuantity = !actions.isQuantityMultiplier(modifier)
+        ? 1
+        : options.itemQuantity;
 
       amountToApply = math.div(
         math.mul(modifierAmount, options.itemTotal),
@@ -57,10 +56,10 @@ module.exports = ({ _, utils, constants, actions }) => {
         action: compute.action || Modifier.Compute.Actions.SUBTRACT,
       },
       properties: {
-        ignoreQuantity:
-          (modifier.properties && modifier.properties.ignoreQuantity) ||
-          type === Modifier.Compute.Types.PERCENTAGE,
         ...(modifier.properties || {}),
+        isQuantityMultiplier:
+          type !== Modifier.Compute.Types.PERCENTAGE &&
+          actions.isQuantityMultiplier(modifier),
       },
     });
     if (maxAmount !== null) delete modifierToAdd.properties.maxAmount;

package/lib/modifier/index.js

@@ -103,7 +103,6 @@ const isAmountOverride = require('./isAmountOverride');
 const isValid = require('./isValid');
 const isDiscount = require('./isDiscount');
 const isHidden = require('./isHidden');
-const isIgnoreQuantity = require('./isIgnoreQuantity');
 const isGratuity = require('./isGratuity');
 const isPaymentMethodModifier = require('./isPaymentMethodModifier');
 const isPaymentTypeModifier = require('./isPaymentTypeModifier');
@@ -148,6 +147,8 @@ const isExtractCalculatedValue = require('./isExtractCalculatedValue');
 const getPriceWithoutModifier = require('./getPriceWithoutModifier');
 const isGroup = require('./isGroup');
 const isOptionsSelectedOverride = require('./isOptionsSelectedOverride');
+const isFixedSubtract = require('./isFixedSubtract');
+const isQuantityMultiplier = require('./isQuantityMultiplier');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -262,7 +263,6 @@ const modifierActions = (deps = {}) => {
     isValid: isValid(innerDeps),
     isDiscount: isDiscount(innerDeps),
     isHidden: isHidden(innerDeps),
-    isIgnoreQuantity: isIgnoreQuantity(innerDeps),
     isGratuity: isGratuity(innerDeps),
     isPaymentMethodModifier: isPaymentMethodModifier(innerDeps),
     isPaymentTypeModifier: isPaymentTypeModifier(innerDeps),
@@ -309,6 +309,8 @@ const modifierActions = (deps = {}) => {
     getPriceWithoutModifier: getPriceWithoutModifier(innerDeps),
     isGroup: isGroup(innerDeps),
     isOptionsSelectedOverride: isOptionsSelectedOverride(innerDeps),
+    isFixedSubtract: isFixedSubtract(innerDeps),
+    isQuantityMultiplier: isQuantityMultiplier(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isFixedSubtract.js

@@ -0,0 +1,4 @@
+module.exports = ({ actions }) =>
+  function isFixedSubtract(modifier) {
+    return actions.isSubtract(modifier) && actions.isFixed(modifier);
+  };

package/lib/modifier/isQuantityMultiplier.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function isQuantityMultiplier(modifier) {
+    if (!modifier || !modifier.properties) return false;
+    return !!modifier.properties.isQuantityMultiplier;
+  };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.53",
+  "version": "1.0.54",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -19,6 +19,7 @@
     "test:item": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/item.test.js",
     "test:split": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/split.test.js",
     "test:getModifierTags": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/item/getModifierTags.test.js",
+    "test:createIndirectModifier": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/modifier/createIndirectModifier.test.js",
     "lint": "eslint --quiet lib/"
   },
   "publishConfig": {
@@ -42,5 +43,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "ad5528b8430430e2a34e124218dc4ac1d3da1681"
+  "gitHead": "8bba2c9f52f54528ea2d0dece82406ef9fe69cb3"
 }

package/lib/modifier/isIgnoreQuantity.js

@@ -1,5 +0,0 @@
-module.exports = () =>
-  function isIgnoreQuantity(modifier) {
-    if (!modifier || !modifier.properties) return false;
-    return modifier.properties.ignoreQuantity;
-  };