@darkpos/pricing 1.0.28 → 1.0.30

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/__TEST__/order/pickEndDate.test.js

@@ -0,0 +1,284 @@
+const moment = require('moment-timezone');
+const _ = require('lodash');
+const pickEndDateFunction = require('../../lib/order/pickEndDate');
+
+describe('pickEndDate function', () => {
+  test('Get calculated Order, one item', () => {
+    const settings = {
+      localization: {
+        locale: 'en-US',
+        hour12: true,
+        currency: 'USD',
+        phoneFormat: 'NATIONAL',
+        timezone: 'America/New_York',
+        defaultCountry: {
+          label: 'United States',
+          value: 'US',
+        },
+        dateFormat: 'default',
+      },
+      schedule: {
+        open: [
+          {
+            groupId: '666b542d5ed0ff34672d9c14',
+            days: [6, 4, 3, 1, 2, 5],
+            startTime: '04:00',
+            endTime: '17:05',
+          },
+          {
+            startTime: '07:00',
+            endTime: '22:04',
+            days: [1, 2],
+          },
+        ],
+        close: [
+          {
+            date: '2024-08-27',
+          },
+        ],
+      },
+    };
+
+    const pickEndDate = pickEndDateFunction({ settings, _, moment });
+    const schedule = {
+      addDays: 1,
+      hour: 17,
+      minute: 0,
+      skipDays: [7],
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 2,
+    };
+
+    const now = moment('2024-08-25T15:00:00Z').tz('America/New_York');
+
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+    const result = pickEndDate(schedule);
+
+    const expectedDate = now
+      .clone()
+      .add(2, 'days')
+      .set({ hour: 17, minute: 0, second: 0 })
+      .utc()
+      .format();
+
+    expect(result).toBe(expectedDate);
+  });
+
+  test('Order falls on a closed day', () => {
+    const settings = {
+      localization: {
+        locale: 'en-US',
+        hour12: true,
+        currency: 'USD',
+        phoneFormat: 'NATIONAL',
+        timezone: 'America/New_York',
+        defaultCountry: {
+          label: 'United States',
+          value: 'US',
+        },
+        dateFormat: 'default',
+      },
+      schedule: {
+        open: [
+          {
+            groupId: '666b542d5ed0ff34672d9c14',
+            days: [1, 2, 3, 4, 5], // Monday to Friday
+            startTime: '04:00',
+            endTime: '17:05',
+          },
+        ],
+        close: [
+          {
+            date: '2024-08-28', // Wednesday is closed
+          },
+        ],
+      },
+    };
+
+    const pickEndDate = pickEndDateFunction({ settings, _, moment });
+    const schedule = {
+      addDays: 1,
+      hour: 17,
+      minute: 0,
+      skipDays: [7], // Skip Sunday
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 2,
+    };
+
+    const now = moment('2024-08-27T15:00:00Z').tz('America/New_York'); // Tuesday
+
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+    const result = pickEndDate(schedule);
+
+    const expectedDate = now
+      .clone()
+      .add(2, 'days') // Skips the closed Wednesday, goes to Thursday
+      .set({ hour: 17, minute: 0, second: 0 })
+      .utc()
+      .format();
+
+    expect(result).toBe(expectedDate);
+  });
+
+  test('Order calculated on a weekend', () => {
+    const settings = {
+      localization: {
+        locale: 'en-US',
+        hour12: true,
+        currency: 'USD',
+        phoneFormat: 'NATIONAL',
+        timezone: 'America/New_York',
+        defaultCountry: {
+          label: 'United States',
+          value: 'US',
+        },
+        dateFormat: 'default',
+      },
+      schedule: {
+        open: [
+          {
+            groupId: '666b542d5ed0ff34672d9c14',
+            days: [1, 2, 3, 4, 5], // Monday to Friday
+            startTime: '04:00',
+            endTime: '17:05',
+          },
+        ],
+        close: [],
+      },
+    };
+
+    const pickEndDate = pickEndDateFunction({ settings, _, moment });
+    const schedule = {
+      addDays: 1,
+      hour: 17,
+      minute: 0,
+      skipDays: [6, 7], // Skip Saturday and Sunday
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 5,
+    };
+
+    const now = moment('2024-08-23T15:00:00Z').tz('America/New_York'); // Friday
+
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+    const result = pickEndDate(schedule);
+
+    const expectedDate = now
+      .clone()
+      .add(3, 'days') // Skips weekend, goes to Monday
+      .set({ hour: 17, minute: 0, second: 0 })
+      .utc()
+      .format();
+
+    expect(result).toBe(expectedDate);
+  });
+
+  test('Order time before cut-off hour', () => {
+    const settings = {
+      localization: {
+        locale: 'en-US',
+        hour12: true,
+        currency: 'USD',
+        phoneFormat: 'NATIONAL',
+        timezone: 'America/New_York',
+        defaultCountry: {
+          label: 'United States',
+          value: 'US',
+        },
+        dateFormat: 'default',
+      },
+      schedule: {
+        open: [
+          {
+            groupId: '666b542d5ed0ff34672d9c14',
+            days: [1, 2, 3, 4, 5], // Monday to Friday
+            startTime: '04:00',
+            endTime: '17:05',
+          },
+        ],
+        close: [],
+      },
+    };
+
+    const pickEndDate = pickEndDateFunction({ settings, _, moment });
+    const schedule = {
+      addDays: 0, // Same day
+      hour: 17,
+      minute: 0,
+      skipDays: [],
+      cutHour: { hour: 16, minute: 0 }, // Cut-off at 4 PM
+      cutDay: 5,
+    };
+
+    const now = moment('2024-08-25T15:00:00Z').tz('America/New_York'); // Friday, before cut-off
+
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+    const result = pickEndDate(schedule);
+
+    const expectedDate = now
+      .clone()
+      .set({ hour: 17, minute: 0, second: 0 })
+      .utc()
+      .format();
+
+    expect(result).toBe(expectedDate);
+  });
+  test('Order time after cut-off hour', () => {
+    const settings = {
+      localization: {
+        locale: 'en-US',
+        hour12: true,
+        currency: 'USD',
+        phoneFormat: 'NATIONAL',
+        timezone: 'America/New_York',
+        defaultCountry: {
+          label: 'United States',
+          value: 'US',
+        },
+        dateFormat: 'default',
+      },
+      schedule: {
+        open: [
+          {
+            groupId: '666b542d5ed0ff34672d9c14',
+            days: [1, 2, 3, 4, 5], // Monday to Friday
+            startTime: '04:00',
+            endTime: '17:05',
+          },
+        ],
+        close: [],
+      },
+    };
+
+    const pickEndDate = pickEndDateFunction({ settings, _, moment });
+    const schedule = {
+      hour: 17,
+      minute: 0,
+      cutDay: 5,
+      skipDays: [],
+      cutHour: {
+        hour: 0,
+        minute: 0,
+      },
+      time: {
+        hour: 16,
+        minute: 0,
+      },
+      addDays: 1,
+      recommended: 'nothing_recommended',
+    };
+
+    const now = moment().tz('America/New_York'); // Friday, after cut-off
+
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
+    const result = pickEndDate(schedule);
+
+    const expectedDate = now
+      .clone()
+      .add(6, 'days') // Skips weekend, goes to Monday
+      .set({ hour: 17, minute: 0, second: 0 })
+      .utc()
+      .format();
+
+    expect(result).toBe(expectedDate);
+  });
+});

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/lib/order/pickEndDate.js

@@ -7,8 +7,7 @@ module.exports = ({ settings, _, moment }) => {
 
     if (!Array.isArray(close)) return [];
     return close.map(closedDate => ({
-      isoWeekDay: moment(closedDate.date).tz(timezone).isoWeekday(),
-      date: moment(closedDate.date).tz(timezone),
+      date: moment(closedDate.date), // the date is saved with the user timezone, no need to convert it back here (ex: date: '2024-08-27' would become date:'2024-08-26 23:00 -4:00')
     }));
   };
 
@@ -27,27 +26,28 @@ module.exports = ({ settings, _, moment }) => {
 
     const closedDays = getClosedDays();
 
-    if (cutHour && todayTZ.get('hours') > cutHour.hour ||
-    (
-     todayTZ.get('hours') >= cutHour.hour && 
-     todayTZ.get('minutes') > cutHour.minute
-    )
-  ) {
+    if (
+      (cutHour && todayTZ.get('hours') > cutHour.hour) ||
+      (todayTZ.get('hours') >= cutHour.hour &&
+        todayTZ.get('minutes') > cutHour.minute)
+    ) {
       endDateTZ = endDateTZ.add(cutDay, 'days');
     }
 
     let addDaysCounter = 0;
-
-    while (addDaysCounter < addDays) {
+    // adding the skip days to the loop
+    const loop = addDays + skipDays.length;
+    while (addDaysCounter < loop) {
       endDateTZ = endDateTZ.add(1, 'days');
       const endDateISOWeekday = endDateTZ.isoWeekday();
-
+      // does the current endDateISOWeekday match with any skip day?
+      // is endDateISOWeekday a sunday?
       const shouldSkip =
-        skipDays.includes(endDateISOWeekday) ||
-        (endDateISOWeekday === 7 && skipDays === 0);
-
+        skipDays.includes(endDateISOWeekday) || endDateISOWeekday === 7;
+      // if addDaysCounter is greater than loop, than we shouldn't add more days
+      // day condition stays working until addDaysCounter is greater than loop
       if (
-        !shouldSkip &&
+        !shouldSkip ||
         !closedDays.some(closedDay => closedDay.date.isSame(endDateTZ, 'day'))
       ) {
         addDaysCounter++;
@@ -60,4 +60,4 @@ module.exports = ({ settings, _, moment }) => {
 
     return moment.utc(endDateTZ).format();
   };
-}; 
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -36,5 +36,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "b6e37fe06bd25e18c66d7b2f1a06fb1c50bd0db6"
+  "gitHead": "a2b20141126aa1c7eb18c345a8aef54d3f6b0821"
 }