@darkpos/pricing 1.0.107 → 1.0.109

package/__TEST__/item.test.js

@@ -1557,4 +1557,278 @@ describe('Item actions', () => {
       'No Clean (0 Unit @ $0.00/Unit)'
     );
   });
+
+  test('Should not apply modifier value when extractCalculatedValue is true but modifier is invalid', () => {
+    const prepayDiscount50Percent = {
+      compute: {
+        amount: 50,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      properties: {
+        extractCalculatedValue: true,
+      },
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'payment',
+            value: 'prepay',
+            operand: '$in',
+          },
+        ],
+      },
+      name: 'percentageDiscount50',
+      type: 'discount',
+    };
+
+    const orderItem = {
+      price: 7.59,
+      quantity: 1,
+      modifiers: [prepayDiscount50Percent],
+    };
+    const order = {
+      items: [orderItem],
+    };
+
+    const calculatedOrder = pricingService.order.calculate(order);
+
+    expect(calculatedOrder.total).toBe(7.59);
+    expect(calculatedOrder.items[0].price).toBe(7.59);
+    expect(calculatedOrder.items[0].total).toBe(7.59);
+    expect(calculatedOrder.items[0].modifiers.length).toBe(1);
+    expect(calculatedOrder.items[0].modifiers[0]._computed).toMatchObject({
+      amount: 0,
+      description: 'percentageDiscount50',
+    });
+  });
+
+  test('Should apply modifier value when extractCalculatedValue is true and modifier is valid', () => {
+    const prepayDiscount50Percent = {
+      compute: {
+        amount: 50,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      properties: {
+        extractCalculatedValue: true,
+      },
+      name: 'percentageDiscount50',
+      type: 'discount',
+    };
+
+    const orderItem = {
+      price: 7.59,
+      quantity: 1,
+      modifiers: [prepayDiscount50Percent],
+    };
+    const order = {
+      items: [orderItem],
+    };
+
+    const calculatedOrder = pricingService.order.calculate(order);
+
+    expect(calculatedOrder.total).toBe(7.59);
+    expect(calculatedOrder.items[0].price).toBe(7.59);
+    expect(calculatedOrder.items[0].total).toBe(7.59);
+    expect(calculatedOrder.items[0].modifiers.length).toBe(1);
+    expect(calculatedOrder.items[0].modifiers[0]._computed).toMatchObject({
+      amount: -7.59,
+      description: 'percentageDiscount50 (-$7.59)',
+    });
+  });
+
+  test('Should apply modifier value when extractCalculatedValue is true and modifier is valid (being also a payment modifier)', () => {
+    const prepayDiscount50Percent = {
+      compute: {
+        amount: 50,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      properties: {
+        extractCalculatedValue: true,
+      },
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'payment',
+            value: 'prepay',
+            operand: '$in',
+          },
+        ],
+      },
+      name: 'percentageDiscount50',
+      type: 'discount',
+    };
+
+    const orderItem = {
+      price: 7.59,
+      quantity: 1,
+      modifiers: [prepayDiscount50Percent],
+    };
+    const order = {
+      items: [orderItem],
+    };
+
+    const calculatedOrder = pricingService.order.calculate(order, {
+      isPrepay: true,
+    });
+
+    expect(calculatedOrder.total).toBe(7.59);
+    expect(calculatedOrder.items[0].price).toBe(7.59);
+    expect(calculatedOrder.items[0].total).toBe(7.59);
+    expect(calculatedOrder.items[0].modifiers.length).toBe(2);
+
+    expect(calculatedOrder.items[0].modifiers[0]._computed).toMatchObject({
+      amount: 0,
+      description: 'percentageDiscount50',
+    });
+    expect(calculatedOrder.items[0].modifiers[1]._computed).toMatchObject({
+      amount: -7.59,
+      description: '$7.59 discount (-$7.59)',
+    });
+  });
+
+  test('Should use a price override modifier and quantity override modifier in combination accordingly', () => {
+    const overridePriceMod = {
+      _id: '675354ee39a47228afd1f1a4',
+      attributes: ['override'],
+      modifierId: '6751f7eeb60c71cefee138ee',
+      name: 'Override item price fixed 0',
+      tags: ['default', 'all'],
+      direct: true,
+      properties: {
+        override: {
+          type: 'fixed',
+          field: 'price',
+          fixedValue: 0,
+          multiplier: false,
+        },
+      },
+    };
+    const overrideQuantityMod = {
+      _id: '675354ee39a47228afd1f1a5',
+      attributes: ['override'],
+      modifierId: '6751f7eeb60c71cefee138ff',
+      name: 'Override item quantity fixed 20',
+      tags: ['default', 'all'],
+      direct: true,
+      properties: {
+        override: {
+          type: 'fixed',
+          field: 'quantity',
+          fixedValue: 20,
+          multiplier: false,
+        },
+      },
+    };
+
+    const itemWithModifierAmountFixed10 = {
+      name: "Men's 3pc Tuxedo",
+      pieces: 1,
+      price: 10,
+      quantity: 1,
+      modifiers: [overridePriceMod, overrideQuantityMod],
+      _id: '675354e939a47228afd1f199',
+      itemId: '62cdbfd01ee1b400193281ee',
+    };
+    const newItem = pricingService.item.calculate(
+      itemWithModifierAmountFixed10
+    );
+    expect(newItem.price).toBe(0);
+    expect(newItem.total).toBe(0);
+    expect(newItem.quantity).toBe(20);
+    expect(newItem).toHaveProperty('price', 0);
+    expect(newItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: 0,
+      description: 'Override item price fixed 0 ($0.00/Unit)',
+    });
+
+    expect(newItem.modifiers[1]).toHaveProperty('_computed', {
+      amount: 0,
+      description: 'Override item quantity fixed 20',
+    });
+
+    expect(newItem).toHaveProperty('subTotals', {
+      _included: 0,
+      _xincluded: 0,
+      _direct: 0,
+      _xdirect: 0,
+      _simple: 0,
+      _actual: 0,
+    });
+  });
+
+  test('Should use a total override modifier and quantity override modifier in combination accordingly', () => {
+    const overrideTotalMod = {
+      _id: '675354ee39a47228afd1f1a4',
+      attributes: ['override'],
+      modifierId: '6751f7eeb60c71cefee138ee',
+      name: 'Override item total fixed 0',
+      tags: ['default', 'all'],
+      direct: true,
+      properties: {
+        override: {
+          type: 'fixed',
+          field: 'total',
+          fixedValue: 0,
+          multiplier: false,
+        },
+        sort: 2,
+      },
+    };
+    const overrideQuantityMod = {
+      _id: '675354ee39a47228afd1f1a5',
+      attributes: ['override'],
+      modifierId: '6751f7eeb60c71cefee138ff',
+      name: 'Override item quantity fixed 20',
+      tags: ['default', 'all'],
+      direct: true,
+      properties: {
+        override: {
+          type: 'fixed',
+          field: 'quantity',
+          fixedValue: 20,
+          multiplier: false,
+        },
+        sort: 1,
+      },
+    };
+
+    const itemWithModifierAmountFixed10 = {
+      name: "Men's 3pc Tuxedo",
+      pieces: 1,
+      price: 10,
+      quantity: 1,
+      modifiers: [overrideTotalMod, overrideQuantityMod],
+      _id: '675354e939a47228afd1f199',
+      itemId: '62cdbfd01ee1b400193281ee',
+    };
+    const newItem = pricingService.item.calculate(
+      itemWithModifierAmountFixed10
+    );
+    expect(newItem.price).toBe(10);
+    expect(newItem.total).toBe(0);
+    expect(newItem.quantity).toBe(20);
+    expect(newItem.modifiers[0]).toHaveProperty('_computed', {
+      amount: 0,
+      description: 'Override item quantity fixed 20',
+    });
+
+    expect(newItem.modifiers[1]).toHaveProperty('_computed', {
+      amount: -200,
+      description: 'Override item total fixed 0 (-$200.00)',
+    });
+
+    expect(newItem).toHaveProperty('subTotals', {
+      _included: 0,
+      _xincluded: -200,
+      undefined: -200,
+      _direct: -200,
+      _xdirect: 0,
+      _simple: 200,
+      _actual: 200,
+    });
+  });
 });

package/lib/item/calculate.js

@@ -40,10 +40,6 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       item.properties.overwrittenQuantity = undefined;
     }
 
-    const price = parseFloat(actions.getPriceWithoutModifiers({ item }));
-    let quantity = parseInt(item.quantity, 10);
-    subTotals._simple = math.mul(price, quantity);
-
     const modifiers = [];
     let { modifiers: itemModifiersPrev = [] } =
       actions.removeModifiersByQuantity(item);
@@ -103,6 +99,15 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         );
       });
 
+    let price = parseFloat(
+      actions.getPriceWithoutModifiers({
+        price: item.price,
+        modifiers: validatedModifiers,
+      })
+    );
+    let quantity = parseInt(item.quantity, 10);
+    subTotals._simple = math.mul(price, quantity);
+
     const modifiersToNotCompute = actions.getModifiersToNotCompute({
       item,
       validatedModifiers,
@@ -169,6 +174,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
             overwrittenPrice: item.price,
           };
           item.price = priceOverride;
+          price = priceOverride;
         }
 
         if (modifierActions.isQuantityOverride(modifier)) {
@@ -177,7 +183,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
             ...(item.properties ? item.properties : {}),
             overwrittenQuantity: item.quantity,
           };
-          subTotals._simple = math.mul(price, newQuantity);
+          subTotals._simple = math.mul(item.price, newQuantity);
           item.quantity = parseInt(newQuantity, 10);
           quantity = parseInt(newQuantity, 10);
         }

package/lib/item/getPriceWithoutModifiers.js

@@ -1,17 +1,15 @@
 module.exports = ({ actions, modifierActions }) =>
   /* eslint-disable no-restricted-syntax */
-  function getPriceWithoutModifiers({ item }) {
-    const basePrice = actions.getBasePrice(item);
+  function getPriceWithoutModifiers({ price, modifiers }) {
+    const basePrice = actions.getBasePrice({ price });
 
-    if (
-      !item ||
-      !Array.isArray(item.modifiers) ||
-      typeof basePrice !== 'number'
-    )
+    if (!Array.isArray(modifiers) || typeof basePrice !== 'number')
       return basePrice;
 
-    const calculatedModifiers = item.modifiers.filter(modifier =>
-      modifierActions.isExtractCalculatedValue({ modifier })
+    const calculatedModifiers = modifiers.filter(
+      modifier =>
+        modifierActions.isValid(modifier) &&
+        modifierActions.isExtractCalculatedValue({ modifier })
     );
 
     if (calculatedModifiers.length === 0) return basePrice;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.107",
+  "version": "1.0.109",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -54,5 +54,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "16a66c27afee8501a123219c6653b59800654b81"
+  "gitHead": "a971788284c326a00e19c914ffbfdc22f1069c72"
 }