@darkpos/pricing 1.0.29 → 1.0.31

package/__TEST__/order/addItem.test.js

@@ -0,0 +1,197 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+const addItemObj = require('../mocks/addItemMock');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+describe('addItem function', () => {
+  test('should add a new item to an empty order', () => {
+    const addItem = pricingService.order.addItem;
+
+    // Mock an empty order
+    const order = {
+      items: [],
+    };
+
+    // Mock item to add
+    const item = {
+      itemId: '123',
+      quantity: 1,
+      price: 100,
+      modifiers: [],
+    };
+
+    // Call the function
+    const [updatedOrder, itemIndex, addedItem] = addItem({
+      order,
+      item,
+      itemIndex: -1, // No existing item in order
+      cache: addItemObj.cache, // Assuming some cache object
+      overridenQuantity: -1, // No overridden quantity
+    });
+
+    // Assertions
+    expect(updatedOrder.items).toHaveLength(1); // Should have one item
+    expect(updatedOrder.items[0].itemId).toBe('123'); // Item ID should match
+    expect(updatedOrder.items[0].quantity).toBe(1); // Quantity should be 1
+    expect(updatedOrder.items[0].price).toBe(100); // Price should be 100
+    expect(itemIndex).toBe(0); // Index of the added item should be 0
+    expect(addedItem).toEqual(updatedOrder.items[0]); // Added item should match the one in the order
+  });
+
+  test('should combine with an existing item if aggregation is enabled', () => {
+    const addItem = pricingService.order.addItem;
+
+    // Mock order with one existing item
+    const order = {
+      items: [
+        {
+          itemId: '123',
+          quantity: 1,
+          price: 100,
+          modifiers: [],
+        },
+      ],
+    };
+
+    // Mock item to add (same as existing item)
+    const item = {
+      itemId: '123',
+      quantity: 1,
+      price: 100,
+      modifiers: [],
+    };
+
+    // Call the function
+    const [updatedOrder, itemIndex, addedItem] = addItem({
+      order,
+      item,
+      itemIndex: -1, // Assuming no explicit index
+      cache: addItemObj.cache, // Assuming some cache object
+      overridenQuantity: -1, // No overridden quantity
+    });
+
+    // Assertions
+    expect(updatedOrder.items).toHaveLength(1); // Should still have one item
+    expect(updatedOrder.items[0].quantity).toBe(2); // Quantity should be 2 (aggregated)
+    expect(itemIndex).toBe(0); // Index should be 0
+    expect(addedItem.quantity).toBe(2); // Added item should have combined quantity
+  });
+
+  test('should add item with overridden quantity', () => {
+    const addItem = pricingService.order.addItem;
+
+    // Mock order with one existing item
+    const order = {
+      items: [],
+    };
+
+    // Mock item to add
+    const item = {
+      itemId: '456',
+      quantity: 1,
+      price: 200,
+      modifiers: [],
+    };
+
+    // Call the function with an overridden quantity
+    const [updatedOrder, itemIndex, addedItem] = addItem({
+      order,
+      item,
+      itemIndex: -1, // Assuming no explicit index
+      cache: addItemObj.cache, // Assuming some cache object
+      overridenQuantity: 5, // Override quantity to 5
+    });
+
+    // Assertions
+    expect(updatedOrder.items).toHaveLength(1); // Should have one item
+    expect(updatedOrder.items[0].quantity).toBe(5); // Quantity should be overridden to 5
+    expect(addedItem.quantity).toBe(5); // Added item should reflect overridden quantity
+  });
+
+  test('should handle adding an item with modifiers', () => {
+    const addItem = pricingService.order.addItem;
+
+    // Mock order with one existing item
+    const order = {
+      items: [],
+    };
+
+    // Mock item to add with modifiers
+    const item = {
+      itemId: '789',
+      quantity: 1,
+      price: 150,
+      modifiers: [
+        {
+            "_id": "66cdf18a1e48455e128a4f63",
+            "modifierId": 'mod1',
+            "_parentId": null,
+            "name": null,
+            "sku": null,
+            "description": null,
+            "group": null,
+            "type": null,
+            "attributes": [],
+            "color": null,
+            "backgroundColor": null,
+            "icon": null,
+            "url": null,
+            "tags": [],
+            "order": null,
+            "included": false,
+            "direct": true,
+            "hidden": false,
+            "required": false,
+            "code": null,
+            "properties": null,
+            "_computed": null
+        },
+        {
+            "_id": "66cdf18a1e48455e128a4f64",
+            "modifierId": 'mod2',
+            "_parentId": null,
+            "name": null,
+            "sku": null,
+            "description": null,
+            "group": null,
+            "type": null,
+            "attributes": [],
+            "color": null,
+            "backgroundColor": null,
+            "icon": null,
+            "url": null,
+            "tags": [],
+            "order": null,
+            "included": false,
+            "direct": true,
+            "hidden": false,
+            "required": false,
+            "code": null,
+            "properties": null,
+            "_computed": null
+        },
+      ],
+    };
+
+    // Call the function
+    const [updatedOrder, itemIndex, addedItem] = addItem({
+      order,
+      item,
+      itemIndex: -1, // Assuming no explicit index
+      cache: addItemObj.cache, // Assuming some cache object
+      overridenQuantity: -1, // No overridden quantity
+    });
+    
+    // Assertions
+    expect(updatedOrder.items).toHaveLength(1); // Should have one item
+    expect(updatedOrder.items[0].modifiers).toHaveLength(2); // Item should have two modifiers
+    expect(updatedOrder.items[0].modifiers[0].modifierId).toBe('66cdf18a1e48455e128a4f63'); // Check first modifier
+    expect(updatedOrder.items[0].modifiers[1].modifierId).toBe('66cdf18a1e48455e128a4f64'); // Check second modifier
+    expect(updatedOrder.items[0].modifiers).toHaveLength(2); // Added item should have modifiers
+  });
+});

package/__TEST__/order/getSameItems.test.js

@@ -0,0 +1,101 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+describe('getSameItems function', () => {
+  test('Get calculated Order, one item', () => {
+    const { getSameItems } = pricingService.order;
+
+    // Mock order with one item
+    const order = {
+      items: [
+        {
+          itemId: '123',
+          menuId: 'menu1',
+          path: [1, 2, 3],
+          serial: null,
+        },
+      ],
+    };
+
+    // Mock item to compare
+    const item = {
+      itemId: '123',
+      menuId: 'menu1',
+      path: [1, 2, 3],
+      serial: null,
+    };
+
+    // Call the function
+    const result = getSameItems({ order, item });
+
+    // Assertions
+    expect(result).toHaveLength(1); // Expecting one match
+    expect(result[0]).toEqual(order.items[0]); // The matched item should be the same as the one in the order
+  });
+
+  test('No match due to different itemId', () => {
+    const { getSameItems } = pricingService.order;
+
+    // Mock order with one item
+    const order = {
+      items: [
+        {
+          itemId: '123',
+          menuId: 'menu1',
+          path: [1, 2, 3],
+          serial: null,
+        },
+      ],
+    };
+
+    // Mock item to compare with a different itemId
+    const item = {
+      itemId: '456',
+      menuId: 'menu1',
+      path: [1, 2, 3],
+      serial: null,
+    };
+
+    // Call the function
+    const result = getSameItems({ order, item });
+
+    // Assertions
+    expect(result).toHaveLength(0); // Expecting no matches
+  });
+
+  test('No match due to different path', () => {
+    const { getSameItems } = pricingService.order;
+
+    // Mock order with one item
+    const order = {
+      items: [
+        {
+          itemId: '123',
+          menuId: 'menu1',
+          path: [1, 2, 3],
+          serial: null,
+        },
+      ],
+    };
+
+    // Mock item to compare with a different path
+    const item = {
+      itemId: '123',
+      menuId: 'menu1',
+      path: [4, 5, 6],
+      serial: null,
+    };
+
+    // Call the function
+    const result = getSameItems({ order, item });
+
+    // Assertions
+    expect(result).toHaveLength(0); // Expecting no matches
+  });
+});

package/lib/modifier/createIndirectModifier.js

@@ -11,7 +11,7 @@ module.exports = ({ _, utils, constants, actions }) => {
   ) {
     const maxAmount = actions.getProperty(modifier, 'maxAmount');
 
-    const { compute = {} } = modifier;
+    const compute = modifier.compute || {};
     const { type, amount = 0 } = compute;
     let modifierAmount = amount;
 

package/lib/order/getSameItems.js

@@ -4,8 +4,8 @@ module.exports = () =>
     return items.filter(each => {
       let check =
         each.itemId &&
-        item._id &&
-        each.itemId === item._id &&
+        item.itemId &&
+        each.itemId === item.itemId &&
         !each.serial &&
         !item.serial;
       if (check && each.menuId && item.menuId) {
@@ -13,7 +13,6 @@ module.exports = () =>
           each.menuId === item.menuId &&
           each.path.toString() === item.path.toString();
       }
-
       return check;
     });
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.29",
+  "version": "1.0.31",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -36,5 +36,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "2b7284fc85592dc13f7026d605c62aaa00e18459"
+  "gitHead": "a864feac96c47884de2da753f60ea69856bcb914"
 }