@darkpos/pricing 1.0.31 → 1.0.33

package/__TEST__/order/addItem.test.js

@@ -10,7 +10,7 @@ const pricingService = usePricing(session);
 
 describe('addItem function', () => {
   test('should add a new item to an empty order', () => {
-    const addItem = pricingService.order.addItem;
+    const { addItem } = pricingService.order;
 
     // Mock an empty order
     const order = {
@@ -44,7 +44,7 @@ describe('addItem function', () => {
   });
 
   test('should combine with an existing item if aggregation is enabled', () => {
-    const addItem = pricingService.order.addItem;
+    const { addItem } = pricingService.order;
 
     // Mock order with one existing item
     const order = {
@@ -83,7 +83,7 @@ describe('addItem function', () => {
   });
 
   test('should add item with overridden quantity', () => {
-    const addItem = pricingService.order.addItem;
+    const { addItem } = pricingService.order;
 
     // Mock order with one existing item
     const order = {
@@ -99,7 +99,7 @@ describe('addItem function', () => {
     };
 
     // Call the function with an overridden quantity
-    const [updatedOrder, itemIndex, addedItem] = addItem({
+    const [updatedOrder, , addedItem] = addItem({
       order,
       item,
       itemIndex: -1, // Assuming no explicit index
@@ -114,7 +114,7 @@ describe('addItem function', () => {
   });
 
   test('should handle adding an item with modifiers', () => {
-    const addItem = pricingService.order.addItem;
+    const { addItem } = pricingService.order;
 
     // Mock order with one existing item
     const order = {
@@ -128,70 +128,74 @@ describe('addItem function', () => {
       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: '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
+          _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({
+    const [updatedOrder] = 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[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/adjustFixedModifiersDifference.test.js

@@ -0,0 +1,117 @@
+const adjustFixedModifiersDifferenceFunction = require('../../lib/order/adjustFixedModifiersDifference');
+
+describe('adjustFixedModifiersDifference Function', () => {
+  const math = {
+    add: jest.fn(),
+  };
+  const _ = {
+    get: jest.fn(),
+  };
+  const actions = {
+    isOpen: jest.fn(),
+    calculate: jest.fn(),
+  };
+
+  const modifierActions = {
+    hasFixedModifier: jest.fn(),
+  };
+
+  const getComputeModField = jest.fn();
+
+  const adjustFixedModifiersDifference = adjustFixedModifiersDifferenceFunction(
+    {
+      utils: { math },
+      actions,
+      modifierActions,
+      _,
+    }
+  );
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should adjust the fixed modifier for a suitable subOrder', () => {
+    const subOrders = [
+      { id: 'subOrder1', total: 100, modifiers: [] },
+      {
+        id: 'subOrder2',
+        total: 200,
+        modifiers: [{ compute: { type: 'fixed', amount: 50 } }],
+      },
+    ];
+    const difference = 20;
+
+    modifierActions.hasFixedModifier
+      .mockReturnValueOnce(false)
+      .mockReturnValueOnce(true);
+    actions.isOpen.mockReturnValueOnce(true);
+    getComputeModField.mockReturnValueOnce({ compute: { amount: 50 } });
+    math.add.mockReturnValueOnce(70);
+    actions.calculate.mockReturnValueOnce({
+      id: 'subOrder2',
+      total: 200,
+      modifiers: [{ compute: { type: 'fixed', amount: 70 } }],
+    });
+    _.get.mockReturnValueOnce(50);
+
+    const result = adjustFixedModifiersDifference({ subOrders, difference });
+
+    expect(result).toEqual([
+      { id: 'subOrder1', total: 100, modifiers: [] },
+      {
+        id: 'subOrder2',
+        total: 200,
+        modifiers: [{ compute: { type: 'fixed', amount: 70 } }],
+      },
+    ]);
+
+    expect(math.add).toHaveBeenCalledWith(50, difference);
+  });
+
+  test('should not adjust if no suitable subOrder is found', () => {
+    const subOrders = [
+      {
+        id: 'subOrder1',
+        total: 100,
+        modifiers: [{ compute: { type: 'fixed', amount: 50 } }],
+      },
+      { id: 'subOrder2', total: 50, modifiers: [] },
+    ];
+    const difference = 200;
+
+    modifierActions.hasFixedModifier
+      .mockReturnValueOnce(true)
+      .mockReturnValueOnce(false);
+    actions.isOpen.mockReturnValueOnce(true).mockReturnValueOnce(true);
+
+    const result = adjustFixedModifiersDifference({ subOrders, difference });
+
+    expect(result).toEqual(subOrders);
+    expect(math.add).not.toHaveBeenCalled();
+    expect(actions.calculate).not.toHaveBeenCalled();
+  });
+
+  test('should not adjust if no suitable subOrder is found and compute is null', () => {
+    const subOrders = [
+      {
+        id: 'subOrder1',
+        total: 100,
+        modifiers: [{ compute: null }],
+      },
+      { id: 'subOrder2', total: 50, modifiers: [] },
+    ];
+    const difference = 200;
+
+    modifierActions.hasFixedModifier
+      .mockReturnValueOnce(true)
+      .mockReturnValueOnce(false);
+    actions.isOpen.mockReturnValueOnce(true).mockReturnValueOnce(true);
+
+    const result = adjustFixedModifiersDifference({ subOrders, difference });
+
+    expect(result).toEqual(subOrders);
+    expect(math.add).not.toHaveBeenCalled();
+    expect(actions.calculate).not.toHaveBeenCalled();
+  });
+});

package/__TEST__/order/order.test.js

@@ -2240,4 +2240,51 @@ describe('Order actions', () => {
 
     expect(newOrderFixedModifier).toHaveProperty('total', 120);
   });
+
+  test('Get calculated Order, multiple items and indirect modifiers and null compute', () => {
+    const item1 = {
+      _id: 1,
+      price: 30,
+      quantity: 2,
+    };
+    const item2 = {
+      _id: 2,
+      price: 10,
+      quantity: 1,
+    };
+    const modifier1 = {
+      compute: null,
+      name: 'modifier1',
+      type: 'discount',
+    };
+
+    const order = { items: [item1, item2], modifiers: [modifier1] };
+
+    const newOrder = pricingService.order.calculate(order);
+    expect(newOrder).toHaveProperty('total', 70);
+    expect(newOrder).toHaveProperty('subTotal', 70);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: 0,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 60);
+    expect(newOrder.items[0]).toHaveProperty('subTotals', {
+      discount: 0,
+      _included: 0,
+      _xincluded: 0,
+      _direct: 0,
+      _xdirect: 0,
+      _simple: 60,
+      _actual: 60,
+    });
+    expect(newOrder.items[1]).toHaveProperty('total', 10);
+    expect(newOrder.items[1]).toHaveProperty('subTotals', {
+      discount: 0,
+      _included: 0,
+      _xincluded: 0,
+      _direct: 0,
+      _xdirect: 0,
+      _simple: 10,
+      _actual: 10,
+    });
+  });
 });

package/__TEST__/order/split.test.js

@@ -0,0 +1,356 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+const dryCleaningModNoAutoSplit = {
+  name: 'Dry Cleaning',
+  attributes: ['department'],
+  code: 'D',
+  _id: '66d89d9b4f04f9eb99666483',
+};
+
+const laundryModNoAutoSplit = {
+  name: 'Laundry',
+  attributes: ['department'],
+  code: 'L',
+  _id: '66d89d9b4f04f9eb99666487',
+};
+
+const tailorinModNoAutoSplit = {
+  name: 'Tailoring',
+  attributes: ['department'],
+  code: 'T',
+  _id: '66d89d9b4f04f9eb99666484',
+};
+
+describe('Auto Split', () => {
+  test('Auto split only by department', () => {
+    const { autoSplit } = pricingService.order;
+
+    // Mock item to compare
+    const item1 = {
+      _id: '123',
+      itemId: '234',
+      modifiers: [laundryModNoAutoSplit],
+    };
+
+    const item2 = {
+      _id: '123',
+      itemId: '234',
+      modifiers: [dryCleaningModNoAutoSplit],
+    };
+
+    const item3 = {
+      _id: '567',
+      itemId: '567',
+      modifiers: [tailorinModNoAutoSplit],
+      quantity: 1000,
+      pieces: 2,
+    };
+
+    const item4 = {
+      _id: '444',
+      itemId: '444',
+      quantity: 1000,
+      modifiers: [tailorinModNoAutoSplit],
+      pieces: 2,
+    };
+
+    const subOrders = autoSplit({
+      parentOrder: {
+        items: [item1, item2, item3, item4],
+        status: {},
+        modifiers: [],
+        displayId: 1,
+      },
+    });
+
+    expect(subOrders.length).toEqual(3);
+  });
+
+  test('Auto split by department and Items Quantity', () => {
+    const { autoSplit } = pricingService.order;
+
+    const laundryModMaxItemsQuantity4 = {
+      ...laundryModNoAutoSplit,
+      properties: {
+        department: { autoSplit: true, maxItems: 2, splitUnit: 'quantity' },
+      },
+    };
+
+    // Mock item to compare
+    const item1 = {
+      _id: '123',
+      itemId: '234',
+      modifiers: [laundryModMaxItemsQuantity4],
+      quantity: 5,
+      pieces: 4,
+    };
+
+    const item2 = {
+      _id: '123',
+      itemId: '234',
+      modifiers: [laundryModMaxItemsQuantity4],
+      quantity: 5,
+      pieces: 4,
+    };
+
+    const item3 = {
+      _id: '567',
+      itemId: '567',
+      modifiers: [dryCleaningModNoAutoSplit],
+      quantity: 1000,
+      pieces: 2,
+    };
+
+    const item4 = {
+      _id: '444',
+      itemId: '444',
+      quantity: 1000,
+      modifiers: [tailorinModNoAutoSplit],
+      pieces: 2,
+    };
+
+    const subOrders = autoSplit({
+      parentOrder: {
+        items: [item1, item2, item3, item4],
+        status: {},
+        modifiers: [],
+        displayId: 1,
+      },
+    });
+
+    expect(subOrders.length).toEqual(7);
+  });
+
+  test('Auto split by department and Items Pieces', () => {
+    const { autoSplit } = pricingService.order;
+
+    const laundryModMaxItemsQuantity4 = {
+      ...laundryModNoAutoSplit,
+      properties: {
+        department: { autoSplit: true, maxItems: 2, splitUnit: 'pieces' },
+      },
+    };
+
+    // Mock item to compare
+    const item1 = {
+      _id: '123',
+      itemId: '234',
+      modifiers: [laundryModMaxItemsQuantity4],
+      quantity: 5,
+      pieces: 2,
+    };
+
+    const item2 = {
+      _id: '123',
+      itemId: '234',
+      modifiers: [laundryModMaxItemsQuantity4],
+      quantity: 5,
+      pieces: 2,
+    };
+
+    const item3 = {
+      _id: '567',
+      itemId: '567',
+      modifiers: [dryCleaningModNoAutoSplit],
+      quantity: 1000,
+      pieces: 2,
+    };
+
+    const item4 = {
+      _id: '444',
+      itemId: '444',
+      quantity: 1000,
+      modifiers: [tailorinModNoAutoSplit],
+      pieces: 2,
+    };
+
+    const subOrders = autoSplit({
+      parentOrder: {
+        items: [item1, item2, item3, item4],
+        status: {},
+        modifiers: [],
+        displayId: 1,
+      },
+    });
+
+    expect(subOrders.length).toEqual(12);
+  });
+
+  test('Auto split by department and Items Pieces 2', () => {
+    const { autoSplit } = pricingService.order;
+
+    const laundryModMaxItemsQuantity4 = {
+      ...laundryModNoAutoSplit,
+      properties: {
+        department: { autoSplit: true, maxItems: 6, splitUnit: 'pieces' },
+      },
+    };
+
+    const item1 = {
+      _id: '123',
+      itemId: '234',
+      modifiers: [laundryModMaxItemsQuantity4],
+      quantity: 10,
+      pieces: 2,
+    };
+
+    const subOrders = autoSplit({
+      parentOrder: {
+        items: [item1],
+        status: {},
+        modifiers: [],
+        displayId: 1,
+      },
+    });
+
+    expect(subOrders.length).toEqual(4);
+    expect(subOrders[0].items[0].quantity).toEqual(3);
+    expect(subOrders[1].items[0].quantity).toEqual(3);
+    expect(subOrders[2].items[0].quantity).toEqual(3);
+    expect(subOrders[3].items[0].quantity).toEqual(1);
+  });
+
+  test('Auto split by department and Items Pieces 3', () => {
+    const { autoSplit } = pricingService.order;
+
+    const laundryModMaxItemsQuantity4 = {
+      ...laundryModNoAutoSplit,
+      properties: {
+        department: { autoSplit: true, maxItems: 6, splitUnit: 'pieces' },
+      },
+    };
+
+    const item1 = {
+      _id: '123',
+      itemId: '234',
+      modifiers: [laundryModMaxItemsQuantity4],
+      quantity: 10,
+      pieces: 2,
+    };
+
+    const item2 = {
+      _id: '123',
+      itemId: '234',
+      modifiers: [tailorinModNoAutoSplit],
+      quantity: 5,
+      pieces: 2,
+    };
+
+    const item3 = {
+      _id: '567',
+      itemId: '567',
+      modifiers: [dryCleaningModNoAutoSplit],
+      quantity: 1000,
+      pieces: 2,
+    };
+
+    const subOrders = autoSplit({
+      parentOrder: {
+        items: [item1, item2, item3],
+        status: {},
+        modifiers: [],
+        displayId: 1,
+      },
+    });
+
+    expect(subOrders.length).toEqual(6);
+    expect(subOrders[0].items[0].quantity).toEqual(3);
+    expect(subOrders[1].items[0].quantity).toEqual(3);
+    expect(subOrders[2].items[0].quantity).toEqual(3);
+    expect(subOrders[3].items[0].quantity).toEqual(1);
+    expect(subOrders[4].items[0].quantity).toEqual(5);
+    expect(subOrders[5].items[0].quantity).toEqual(1000);
+  });
+
+  test('Auto split by department and Items Weight', () => {
+    const { autoSplit } = pricingService.order;
+
+    const laundryModMaxItems = {
+      ...laundryModNoAutoSplit,
+      properties: {
+        department: {
+          autoSplit: true,
+          maxItems: 100,
+          splitUnit: 'weight',
+        },
+      },
+    };
+
+    const item1 = {
+      _id: '123',
+      itemId: '234',
+      modifiers: [laundryModMaxItems],
+      quantity: 10,
+      pieces: 2,
+      weight: 30,
+    };
+
+    const subOrders = autoSplit({
+      parentOrder: {
+        items: [item1],
+        status: {},
+        modifiers: [],
+        displayId: 1,
+      },
+    });
+
+    expect(subOrders.length).toEqual(4);
+    expect(subOrders[0].items[0].quantity).toEqual(3);
+    expect(subOrders[1].items[0].quantity).toEqual(3);
+    expect(subOrders[2].items[0].quantity).toEqual(3);
+    expect(subOrders[3].items[0].quantity).toEqual(1);
+  });
+
+  test('Auto split by department and Items Weight 2', () => {
+    const { autoSplit } = pricingService.order;
+
+    const laundryModMaxItems = {
+      ...laundryModNoAutoSplit,
+      properties: {
+        department: {
+          autoSplit: true,
+          maxItems: 25,
+          splitUnit: 'weight',
+        },
+      },
+    };
+
+    const item1 = {
+      _id: '123',
+      itemId: '234',
+      modifiers: [laundryModMaxItems],
+      quantity: 1,
+      pieces: 2,
+      weight: 25,
+    };
+
+    const item2 = {
+      _id: '322',
+      itemId: '4555',
+      modifiers: [laundryModMaxItems],
+      quantity: 1,
+      pieces: 2,
+      weight: 25,
+    };
+
+    const subOrders = autoSplit({
+      parentOrder: {
+        items: [item1, item2],
+        status: {},
+        modifiers: [],
+        displayId: 1,
+      },
+    });
+
+    expect(subOrders.length).toEqual(2);
+    expect(subOrders[0].items[0].quantity).toEqual(1);
+    expect(subOrders[1].items[0].quantity).toEqual(1);
+  });
+});

package/lib/item/addIndirectModifier.js

@@ -1,4 +1,5 @@
-module.exports = ({ utils, modifierActions }) => {
+module.exports = ({ utils, modifierActions, _ }) => {
+  const { getComputeModField } = require('../modifier/utils');
   const { math } = utils;
 
   return function addIndirectModifier({ orderTotal, items, modifier }) {
@@ -25,7 +26,9 @@ module.exports = ({ utils, modifierActions }) => {
       );
     }, 0);
 
-    if (modifier.compute.type === 'percentage' && modifier.type !== 'credit')
+    const modifierType = _.get(modifier, 'modifier.type', '');
+    const computeField = getComputeModField(modifier);
+    if (computeField.type === 'percentage' && modifierType !== 'credit')
       return itemsModifiers;
 
     if (math.abs(totalDistributed) !== math.abs(orderModifierTotal)) {