@darkpos/pricing 1.0.93 → 1.0.95

package/__TEST__/item.test.js

@@ -648,7 +648,6 @@ describe('Item actions', () => {
               multiplier: true,
             },
           },
-          compute: { type: 'fixed', amount: 10, action: 'add' },
         },
       ],
       _id: '675354e939a47228afd1f199',
@@ -679,60 +678,43 @@ describe('Item actions', () => {
   });
 
   test('CU-86dvbn63z: Calculate item with quantity > 1 and quantity override modifier', () => {
+    const quantityOverrideMod = {
+      _id: '67535f3ab4c5ea63d2d7964b',
+      attributes: ['override'],
+      modifierId: '675359b5d08f91f558233f85',
+      name: 'Override Item Quantity 5',
+      group: 'Upcharge',
+      type: 'tax',
+      tags: ['default'],
+      direct: true,
+      properties: {
+        subscription: {},
+        override: { type: 'fixed', field: 'quantity', fixedValue: 5 },
+        group: { items: [], modifiers: [] },
+        department: {},
+        sort: null,
+      },
+      compute: null,
+    };
     const itemWithQuantityOverride5 = {
       name: "Men's 3pc Tuxedo",
       pieces: 3,
       total: 70.88,
       price: 13.5,
-      quantity: 5,
-      modifiers: [
-        {
-          _id: '67535f3ab4c5ea63d2d7964b',
-          attributes: ['override'],
-          modifierId: '675359b5d08f91f558233f85',
-          _parentId: null,
-          locked: false,
-          name: 'Override Item Quantity 5',
-          sku: '',
-          description: '',
-          group: 'Upcharge',
-          type: 'tax',
-          tags: ['default'],
-          order: 0,
-          included: false,
-          direct: true,
-          hidden: false,
-          print: true,
-          required: false,
-          recommended: false,
-          default: false,
-          code: '',
-          properties: {
-            subscription: {},
-            override: { type: 'fixed', field: 'quantity', fixedValue: 5 },
-            group: { items: [], modifiers: [] },
-            department: {},
-            sort: null,
-          },
-          _computed: { amount: 0, description: 'Override Item Quantity 5' },
-          addModifiers: [],
-          delModifiers: [],
-          conditions: { valid: true },
-          compute: null,
-          _createdAt: '2024-12-06T20:08:21.409Z',
-          _updatedAt: '2024-12-06T20:18:37.174Z',
-        },
-      ],
+      quantity: 3,
+      modifiers: [quantityOverrideMod],
       _id: '67535f34b4c5ea63d2d79640',
       properties: { basePrice: 13.5 },
       itemId: '62cdbfd01ee1b400193281ee',
       menuRuleId: '65660855dfffaf2da26fb870',
       __typename: 'OrderItem',
     };
-    const newItem = pricingService.item.calculate(itemWithQuantityOverride5);
+    let newItem = pricingService.item.calculate(itemWithQuantityOverride5);
 
     expect(newItem).toHaveProperty('total', 67.5);
     expect(newItem).toHaveProperty('price', 13.5);
+    expect(newItem).toHaveProperty('quantity', 5);
+
     expect(newItem.modifiers[0]).toHaveProperty('_computed', {
       amount: 0,
       description: 'Override Item Quantity 5',
@@ -746,6 +728,29 @@ describe('Item actions', () => {
       _simple: 67.5,
       _actual: 67.5,
     });
+
+    newItem = pricingService.item.calculate(
+      pricingService.item.removeModifiers({
+        item: newItem,
+        modifiers: [quantityOverrideMod],
+        customer: undefined,
+        order: { items: [newItem] },
+      })
+    );
+    expect(newItem.price).toBe(13.5);
+    expect(newItem.total).toBe(40.5);
+    expect(newItem.quantity).toBe(3);
+
+    expect(newItem.modifiers.length).toBe(0);
+
+    expect(newItem).toHaveProperty('subTotals', {
+      _included: 0,
+      _xincluded: 0,
+      _direct: 0,
+      _xdirect: 0,
+      _simple: 40.5,
+      _actual: 40.5,
+    });
   });
 
   test('CU-86dvbn63z: Calculate item with quantity > 1 and modifieritemPriceFixed10', () => {
@@ -772,7 +777,6 @@ describe('Item actions', () => {
               multiplier: false,
             },
           },
-          compute: { type: 'fixed', amount: 10, action: 'add' },
         },
       ],
       _id: '675354e939a47228afd1f199',
@@ -830,12 +834,6 @@ describe('Item actions', () => {
               multiplier: true,
             },
           },
-          _computed: {
-            amount: 0,
-            description:
-              'Override Item Price 10 USD Multiplier (10 Unit @ $13.50/Unit)',
-          },
-          compute: { amount: 10 },
         },
       ],
       _id: '675360d5bc57ccecf751a5b5',

package/__TEST__/modifier/addItemModifier.test.js

@@ -1,96 +1,217 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+
 const addItemMock = require('./mocks/addItemModifierMock.json');
 const orderMock = require('./mocks/orderMock.json');
-const usePricing = require('../../index');
 
-const pricingService = usePricing();
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
 
 describe('addItemModifier Function', () => {
-  test('Add an override price modifier to the item', () => {
-    let { order } = addItemMock;
-    const { modifier2, itemIndex } = addItemMock;
-
-    /**
-     * modifier2 properties
-     *  "override": {
-            "field": "price",
-            "type": "fixed",
-            "multiplier": null,
-            "fixedValue": 40
-        },
-     */
+  const priceOverrideModifier = {
+    _id: '66ec3e3efe02e7ee35f595be',
+    attributes: ['override'],
+    modifierId: '66ec3e3efe02e7ee35f595be',
+    _parentId: null,
+    locked: false,
+    name: 'Price Override 40',
+    direct: true,
+    properties: {
+      override: {
+        field: 'price',
+        type: 'fixed',
+        multiplier: null,
+        fixedValue: 40,
+      },
+    },
+  };
+  const amountOverrideModifier = {
+    _id: '66ec3e3efe02e7ee35f595bd',
+    attributes: ['override'],
+    modifierId: '66ec3e3efe02e7ee35f595bd',
+    name: 'Amount Override 20',
+    sku: '123123',
+    tags: ['default'],
+    order: 2,
+    direct: true,
+    properties: {
+      override: {
+        field: 'amount',
+        type: 'fixed',
+        fixedValue: 20,
+      },
+    },
+  };
+
+  const baseItem = {
+    name: 'Andre Pants',
+    pieces: 1,
+    total: 2,
+    totalPaid: 0,
+    price: 2,
+    quantity: 1,
+    _id: '66ec759cd57e32c3455724a0',
+    modifiers: [],
+    priceLevels: [
+      {
+        value: 10,
+        tags: ['default'],
+      },
+      {
+        value: 2,
+        tags: ['vip'],
+      },
+      {
+        value: 10,
+        tags: ['default', 'press only'],
+      },
+      {
+        value: 2,
+        tags: ['vip', 'press only'],
+      },
+    ],
+  };
+  test('Add an override price modifier to an item, change the quantity and then remove the modifier', () => {
+    let order = {
+      _id: '66ec7594d57e32c34557249f',
+      customer: {
+        _id: '66bb8d1e38ebaee653177a92',
+        tags: ['default', 'vip'],
+      },
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item: baseItem,
+    }).updatedOrder;
+
     order = pricingService.order.addItemModifier({
       order,
-      modifier: modifier2,
-      itemIndex,
+      modifier: priceOverrideModifier,
+      itemIndex: 0,
     });
 
-    const calculatedOrder = pricingService.order.calculate({
+    order = pricingService.order.calculate({
       ...order,
-      items: order.items,
     });
 
-    const item0 = calculatedOrder.items[0];
-    // Check that the modifier adds the correct fixed amount
-    expect(item0.price).toBe(40);
+    expect(order.items[0].price).toBe(40);
+    expect(order.items[0].total).toBe(40);
+    expect(order.items[0].subTotals).toMatchObject({
+      _actual: 40,
+      _direct: 0,
+      _included: 0,
+      _simple: 40,
+      _xdirect: 0,
+      _xincluded: 0,
+    });
+
+    order = pricingService.order.calculate({
+      ...order,
+      items: [{ ...order.items[0], quantity: 2 }],
+    });
+
+    expect(order.items[0].price).toBe(40);
+    expect(order.items[0].total).toBe(80);
+    expect(order.items[0].subTotals).toMatchObject({
+      _actual: 80,
+      _direct: 0,
+      _included: 0,
+      _simple: 80,
+      _xdirect: 0,
+      _xincluded: 0,
+    });
+
+    const calculatedItem = pricingService.item.calculate(
+      pricingService.item.removeModifier({
+        item: order.items[0],
+        modifier: order.items[0].modifiers[0],
+        order,
+      })
+    );
+
+    expect(calculatedItem.price).toBe(2);
+    expect(calculatedItem.total).toBe(4);
+    expect(calculatedItem.subTotals).toMatchObject({
+      _actual: 4,
+      _direct: 0,
+      _included: 0,
+      _simple: 4,
+      _xdirect: 0,
+      _xincluded: 0,
+    });
   });
   test('Add an override amount to the item', () => {
-    let { order } = addItemMock;
-    const { modifier1, itemIndex } = addItemMock;
-
-    /**
-     * modifier2 properties
-        "override": {
-            "field": "amount",
-            "type": "fixed",
-            "multiplier": null,
-            "fixedValue": 20
-        },
-     */
+    let order = {
+      _id: '66ec7594d57e32c34557249f',
+      customer: {
+        _id: '66bb8d1e38ebaee653177a92',
+        tags: ['default', 'vip'],
+      },
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item: baseItem,
+    }).updatedOrder;
+
     order = pricingService.order.addItemModifier({
       order,
-      modifier: modifier1,
-      itemIndex,
+      modifier: amountOverrideModifier,
+      itemIndex: 0,
     });
 
-    const calculatedOrder = pricingService.order.calculate({
-      ...order,
-      items: order.items,
-    });
-    const item0 = calculatedOrder.items[0];
+    const calculatedOrder = pricingService.order.calculate(order);
 
-    // The item price shouldn't change
-    expect(item0.price).toBe(2);
+    expect(calculatedOrder.items[0].price).toBe(2);
+    expect(calculatedOrder.items[0].total).toBe(22);
+    expect(calculatedOrder.items[0].modifiers[0].compute).toMatchObject({});
+    expect(calculatedOrder.items[0].modifiers[0]._computed).toMatchObject({
+      amount: 20,
+      description: 'Amount Override 20 ($20.00)',
+    });
 
-    // expect the modifier compute amount to match the item
-    expect(item0.modifiers[0].compute.amount).toBe(20);
+    expect(calculatedOrder.items[0].modifiers[0]._computed.amount).toBe(20);
   });
   test('Add an override amount and override at the same time to the item', () => {
-    let { order } = addItemMock;
-    const { modifier1, modifier2, itemIndex } = addItemMock;
+    let order = {
+      _id: '66ec7594d57e32c34557249f',
+      customer: {
+        _id: '66bb8d1e38ebaee653177a92',
+        tags: ['default', 'vip'],
+      },
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item: baseItem,
+    }).updatedOrder;
 
     order = pricingService.order.addItemModifier({
       order,
-      modifier: modifier1,
-      itemIndex,
+      modifier: amountOverrideModifier,
+      itemIndex: 0,
     });
 
     order = pricingService.order.addItemModifier({
       order,
-      modifier: modifier2,
-      itemIndex,
+      modifier: priceOverrideModifier,
+      itemIndex: 0,
     });
 
-    const calculatedOrder = pricingService.order.calculate({
+    order = pricingService.order.calculate({
       ...order,
-      items: order.items,
     });
-    const item0 = calculatedOrder.items[0];
-    // item price should match the price override
-    expect(item0.price).toBe(40);
-    // amount override should be 20
-    expect(item0.modifiers[1].compute.amount).toBe(20);
-    /// price override should be 40
-    expect(item0.modifiers[0].compute.amount).toBe(40);
+
+    expect(order.items[0].price).toBe(40);
+    expect(order.items[0].modifiers[0].compute.amount).toBe(20);
+    expect(order.items[0].modifiers[0]._computed.amount).toBe(20);
+
+    expect(order.items[0].modifiers[1].compute.amount).toBe(40);
+    expect(order.items[0].modifiers[1]._computed.amount).toBe(0);
   });
 
   test('Verify item total after adding the modifier', () => {

package/__TEST__/modifier/overrideModifiers.test.js

@@ -0,0 +1,196 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+describe('Override Modifiers', () => {
+  test('Should calculate override modifier itemTotal: minimum $20 for up to 10 pounds, after 10 pounds it costs $2/pound. (having 8 pounds)', () => {
+    const itemTotalOverride20 = {
+      _id: '682cb7d9c48475c7215b662a',
+      name: 'Minimum $20 for up to 10 pounds',
+      properties: {
+        override: {
+          field: 'total',
+          type: 'fixed',
+          fixedValue: 20,
+        },
+        sort: null,
+      },
+      attributes: ['override'],
+      order: 0,
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'itemQuantity',
+            value: '10',
+            operand: '$lt',
+          },
+        ],
+      },
+      compute: null,
+    };
+
+    const orderItem1 = {
+      price: 2,
+      quantity: 8,
+      modifiers: [itemTotalOverride20],
+    };
+
+    const calculatedItem = pricingService.item.calculate(orderItem1);
+
+    expect(calculatedItem).toHaveProperty('total', 20);
+    expect(calculatedItem.modifiers[0]._computed).toMatchObject({
+      amount: 4,
+      description: 'Minimum $20 for up to 10 pounds ($4.00)',
+    });
+    expect(calculatedItem.modifiers[0].conditions.valid).toBe(true);
+  });
+
+  test('Should calculate override modifier itemTotal: minimum $20 for up to 10 pounds, after 10 pounds it costs $2/pound. (having 12 pounds)', () => {
+    const itemTotalOverride20 = {
+      _id: '682cb7d9c48475c7215b662a',
+      name: 'Minimum $20 for up to 10 pounds',
+      properties: {
+        override: {
+          field: 'total',
+          type: 'fixed',
+          fixedValue: 20,
+        },
+        sort: null,
+      },
+      attributes: ['override'],
+      order: 0,
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'itemQuantity',
+            value: '10',
+            operand: '$lt',
+          },
+        ],
+      },
+      compute: null,
+    };
+
+    const orderItem1 = {
+      price: 2,
+      quantity: 12,
+      modifiers: [itemTotalOverride20],
+    };
+
+    const calculatedItem = pricingService.item.calculate(orderItem1);
+
+    expect(calculatedItem).toHaveProperty('total', 24);
+    expect(calculatedItem.modifiers[0]._computed).toMatchObject({
+      amount: 0,
+      description: 'Minimum $20 for up to 10 pounds',
+    });
+    expect(calculatedItem.modifiers[0].conditions.valid).toBe(false);
+  });
+
+  test('Should Override Notes Modifier', () => {
+    const notesOverrideModifier = {
+      _id: '682cb7d9c48475c7215b662a',
+      name: 'Add Note',
+      properties: {
+        override: {
+          field: 'notes',
+          fixedValue: 'This is a note coming from an override modifier',
+        },
+        sort: null,
+      },
+      attributes: ['override'],
+      order: 0,
+      tags: ['default'],
+      direct: true,
+      conditions: {},
+      compute: null,
+    };
+
+    const orderItem1 = {
+      price: 2,
+      quantity: 8,
+      modifiers: [notesOverrideModifier],
+    };
+
+    const calculatedItem = pricingService.item.calculate(orderItem1);
+
+    expect(calculatedItem).toHaveProperty('total', 16);
+    expect(calculatedItem.notes).toMatchObject([
+      {
+        attributes: [],
+        date: undefined,
+        user: null,
+        message: 'This is a note coming from an override modifier',
+      },
+    ]);
+
+    expect(calculatedItem.modifiers[0]._computed).toMatchObject({
+      amount: 0,
+      description: 'Add Note',
+    });
+    expect(calculatedItem.modifiers[0].conditions.valid).toBe(true);
+  });
+
+  test('Should not Override Notes becuase of conditions', () => {
+    const notesOverrideModifier = {
+      _id: '682cb7d9c48475c7215b662a',
+      name: 'Add Note',
+      properties: {
+        override: {
+          field: 'notes',
+          fixedValue: 'This is a note coming from an override modifier',
+        },
+        sort: null,
+      },
+      attributes: ['override'],
+      order: 0,
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: false,
+        rules: [
+          {
+            key: 'paymentMethods',
+            value: ['cash-cash'],
+            operand: '$in',
+          },
+          {
+            key: 'paymentTypes',
+            value: ['cash'],
+            operand: '$in',
+          },
+        ],
+      },
+      compute: null,
+    };
+
+    const orderItem1 = {
+      price: 2,
+      quantity: 8,
+      modifiers: [notesOverrideModifier],
+      notes: ['hello world'],
+    };
+
+    const calculatedItem = pricingService.item.calculate(orderItem1);
+
+    expect(calculatedItem.total).toBe(16);
+    expect(calculatedItem.notes).toMatchObject(['hello world']);
+
+    expect(calculatedItem.modifiers[0]._computed).toMatchObject({
+      amount: 0,
+      description: 'Add Note',
+    });
+    expect(calculatedItem.modifiers[0].conditions.valid).toBe(false);
+  });
+});

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

@@ -686,7 +686,7 @@ describe('Order actions', () => {
           modifiers: [
             {
               _id: '671818d40e5dd150d9830904',
-              attributes: ['override'],
+              attributes: [],
               modifierId: '62cdbfd01ee1b4001932818f',
               _parentId: null,
               locked: null,
@@ -705,15 +705,7 @@ describe('Order actions', () => {
               recommended: false,
               default: false,
               code: '',
-              properties: {
-                override: {
-                  field: 'price',
-                  type: 'manual',
-                  multiplier: true,
-                },
-                group: null,
-                sort: null,
-              },
+              properties: {},
               _computed: {
                 amount: 0,
                 description: 'Alice Blue',
@@ -1093,7 +1085,7 @@ describe('Order actions', () => {
     expect(resultedOrder.items[0].modifiers[0]._computed).toEqual(
       expect.objectContaining({
         amount: 0,
-        description: 'Alice Blue (0 Unit @ $13.50/Unit)',
+        description: 'Alice Blue',
       })
     );