@darkpos/pricing 1.0.55 → 1.0.57

package/__TEST__/modifier.test.js

@@ -74,6 +74,64 @@ describe('Modifier actions', () => {
       },
     });
 
+    expect(conditionsBag).toEqual([]);
+    expect(error).toEqual('');
+
+    expect(updatedOrder2.items[0].modifiers.length).toEqual(2);
+  });
+
+  test('CU-86dve27tq Should not allow adding a modifier more than once to an item if isQuantityMultiplier={true} QTY={2}', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: true,
+      },
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    const updatedOrder = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+    });
+
+    let error = '';
+    const updatedOrder2 = pricingService.order.addItemModifier({
+      order: { ...updatedOrder },
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+      onError: errorMessage => {
+        error = errorMessage;
+      },
+    });
+
     expect(conditionsBag).toEqual([]);
     expect(error).toEqual('modifier.has.reached.the.maximum.amount.of.applies');
     expect(updatedOrder2).toEqual(updatedOrder);

package/__TEST__/order/pickEndDate.test.js

@@ -1,11 +1,22 @@
 const moment = require('moment-timezone');
 const usePricing = require('../../lib/index');
 
-const pricingService = usePricing();
-const { pickEndDate } = pricingService.store;
+const pricingService = usePricing({
+  store: {
+    _settings: {
+      schedule: {
+        close: [
+          {
+            date: '2024-09-03',
+          },
+        ],
+      },
+    },
+  },
+});
 
 describe('pickEndDate function', () => {
-  test('Get calculated Order, one item', () => {
+  test('Get EndDate, today is an Skip date', () => {
     const schedule = {
       addDays: 1,
       hour: 17,
@@ -16,24 +27,17 @@ describe('pickEndDate function', () => {
     };
 
     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: schedule.hour, minute: schedule.minute, second: 0 })
-      .utc()
-      .format();
+    const result = pricingService.store.pickEndDate(schedule);
 
-    expect(result).toBe(expectedDate);
+    expect(result).toBe('2024-08-27T21:00:00Z'); // 2024-08-27 17:00:00 EDT
   });
 
   test('Order falls on a closed day', () => {
     const schedule = {
       addDays: 1,
-      hour: 17,
+      hour: 14,
       minute: 0,
       skipDays: [7], // Skip Sunday
       cutHour: { hour: 16, minute: 0 },
@@ -43,19 +47,12 @@ describe('pickEndDate function', () => {
     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: schedule.hour, minute: 0, second: 0 })
-      .utc()
-      .format();
+    const result = pricingService.store.pickEndDate(schedule);
 
-    expect(result).toBe(expectedDate);
+    expect(result).toBe('2024-08-28T18:00:00Z'); // 2024-08-28 14:00:00 EDT
   });
 
-  test('Order calculated on a weekend', () => {
+  test('Get endDate if today is friday and Saturday and Sunday are skip days', () => {
     const schedule = {
       addDays: 1,
       hour: 17,
@@ -68,16 +65,9 @@ describe('pickEndDate function', () => {
     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 result = pricingService.store.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);
+    expect(result).toBe('2024-08-26T21:00:00Z'); // 2024-08-26 17:00:00 EDT
   });
 
   test('Order time before cut-off hour', () => {
@@ -93,16 +83,11 @@ describe('pickEndDate function', () => {
     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();
+    const result = pricingService.store.pickEndDate(schedule);
 
-    expect(result).toBe(expectedDate);
+    expect(result).toBe('2024-08-25T21:00:00Z'); // 2024-08-25 17:00:00 EDT
   });
+
   test('Order time after cut-off hour', () => {
     const schedule = {
       hour: 17,
@@ -124,15 +109,44 @@ describe('pickEndDate function', () => {
     const now = moment().tz('America/New_York'); // Friday, after cut-off
 
     jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
-    const result = pickEndDate(schedule);
+    const result = pricingService.store.pickEndDate(schedule);
+
+    expect(result).toBe('2024-08-31T21:00:00Z'); // 2024-08-31 17:00:00 EDT
+  });
+
+  test('Get EndDate, there are skip dates in between', () => {
+    const schedule = {
+      addDays: 1,
+      hour: 17,
+      minute: 0,
+      skipDays: [7, 0],
+      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 = pricingService.store.pickEndDate(schedule);
+
+    expect(result).toBe('2024-08-27T21:00:00Z'); // 2024-08-27 17:00:00 EDT
+  });
+
+  test('Get EndDate, there are skip dates in between and endDate falls in a closed date', () => {
+    const schedule = {
+      addDays: 1,
+      hour: 20,
+      minute: 0,
+      skipDays: [1, 7],
+      cutHour: { hour: 16, minute: 0 },
+      cutDay: 2,
+    };
+
+    const now = moment('2024-09-01T15:00:00Z').tz('America/New_York');
+    jest.spyOn(moment, 'now').mockImplementation(() => now.valueOf());
 
-    const expectedDate = now
-      .clone()
-      .add(6, 'days') // Skips weekend, goes to Monday
-      .set({ hour: 17, minute: 0, second: 0 })
-      .utc()
-      .format();
+    const result = pricingService.store.pickEndDate(schedule);
 
-    expect(result).toBe(expectedDate);
+    expect(result).toBe('2024-09-06T00:00:00Z'); // 2024-09-05 20:00:00 EDT
   });
 });

package/__TEST__/order/unvoid.test.js

@@ -0,0 +1,32 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+const orderNotPaid = require('../mocks/unpaid/order-not-paid.json');
+const constants = require('../../lib/constants/Status');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+describe('Unvoid order', () => {
+  test('Should update status.order to OPEN if order has existing status', () => {
+    const updatedOrder = pricingService.order.unvoidOrder(orderNotPaid);
+    expect(updatedOrder.status.order).toBe(constants.Order.OPEN);
+  });
+
+  test('Should return null if order is null', () => {
+    const updatedOrder = pricingService.order.unvoidOrder(null);
+    expect(updatedOrder).toBeNull();
+  });
+  test('Should return undefined if order is undefined', () => {
+    const updatedOrder = pricingService.order.unvoidOrder(undefined);
+    expect(updatedOrder).toBeUndefined();
+  });
+  test('Should not mutate the original order object', () => {
+    const order = { ...orderNotPaid };
+    const orderClone = JSON.parse(JSON.stringify(orderNotPaid));
+    pricingService.order.unvoidOrder(order);
+    expect(order).toEqual(orderClone);
+  });
+});

package/lib/order/addItemModifier.js

@@ -227,7 +227,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     if (
       contains &&
       modifierActions.isCompute(modifier) &&
-      !modifierActions.isQuantityMultiplier(modifier)
+      modifierActions.isQuantityMultiplier(modifier)
     ) {
       if (onError)
         onError('modifier.has.reached.the.maximum.amount.of.applies');

package/lib/order/index.js

@@ -38,6 +38,7 @@ const addDiscountModifier = require('./addDiscountModifier');
 const calculateDue = require('./calculateDue');
 const toggleModifier = require('./toggleModifier');
 const voidOrder = require('./void');
+const unvoidOrder = require('./unvoid');
 const holdOrder = require('./hold');
 const openOrder = require('./open');
 const isDetailed = require('./isDetailed');
@@ -137,6 +138,7 @@ const orderActions = (deps = {}) => {
     calculateDue: calculateDue(innerDeps),
     toggleModifier: toggleModifier(innerDeps),
     voidOrder: voidOrder(innerDeps),
+    unvoidOrder: unvoidOrder(innerDeps),
     holdOrder: holdOrder(innerDeps),
     openOrder: openOrder(innerDeps),
     isDetailed: isDetailed(innerDeps),

package/lib/order/unvoid.js

@@ -0,0 +1,11 @@
+module.exports = ({ constants }) =>
+  function unvoid(order) {
+    if (!order) return order;
+    return {
+      ...order,
+      status: {
+        ...(order.status || {}),
+        order: constants.Status.Order.OPEN,
+      },
+    };
+  };

package/lib/store/pickEndDate.js

@@ -4,21 +4,20 @@ module.exports = ({ settings, _, moment }) => {
   const getClosedDays = () => {
     const schedule = _.get(settings, 'schedule', {});
     const { close = [] } = schedule;
-
     if (!Array.isArray(close)) return [];
-    return close.map(closedDate => ({
-      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')
-    }));
+    return close;
   };
 
+  const MAX_ADD_DAYS = 365;
+
   return function pickEndDate(schedule = {}) {
     const {
-      addDays = 1,
+      addDays: addDaysParam,
       hour,
       minute,
       skipDays = [],
       cutHour,
-      cutDay = 1,
+      cutDay = 0,
     } = schedule;
 
     const todayTZ = moment().tz(timezone);
@@ -26,36 +25,45 @@ module.exports = ({ settings, _, moment }) => {
     const closedDays = getClosedDays();
     const todayHours = todayTZ.get('hours');
     const todayMinutes = todayTZ.get('minutes');
+
+    const addDays =
+      typeof addDaysParam !== 'number' || addDaysParam > MAX_ADD_DAYS
+        ? 0
+        : addDaysParam;
+
     if (
       (cutHour && todayHours > cutHour.hour) ||
       (todayHours >= cutHour.hour && todayMinutes > cutHour.minute)
     ) {
-      endDateTZ = endDateTZ.add(cutDay, 'days'); // if the cut day is zero should we add a day based on hours? ask Nabil/Vicky
+      endDateTZ = endDateTZ.add(cutDay, 'days');
     }
 
-    endDateTZ.add(addDays, 'days');
-    // do the logic related to skipdays
-    // if the date already pass the skip day, do nothing
-    // if the date is the same as one of the skip day, check the next skip day if any, then add one more day
-    skipDays.forEach(day => {
-      if (todayTZ.isoWeekday() <= day) {
-        endDateTZ.add(1, 'days');
-      }
-    });
-
-    /**
-     * setting the hour and minute so we can compare with closedDays
-     */
-    closedDays.forEach(closed => {
-      const closedDay = moment(closed.date);
-      closedDay.set('hour', hour);
-      closedDay.set('minute', minute);
-      if (endDateTZ.startOf('day').isSame(closedDay, 'day')) {
-        endDateTZ.add(1, 'days');
-      }
-    });
     if (hour !== undefined) endDateTZ.set('hour', hour);
     if (minute !== undefined) endDateTZ.set('minute', minute);
+    endDateTZ.set('second', 0);
+
+    const isSkipDay = endDateIsoWeekDay => {
+      if (skipDays.length >= 7) return false;
+      return skipDays.includes(endDateIsoWeekDay);
+    };
+
+    const isClosedDay = endDate =>
+      closedDays.some(
+        closedDate => endDate.format('YYYY-MM-DD') === closedDate.date
+      );
+
+    let addedDays = 0;
+
+    while (
+      addedDays < addDays ||
+      isSkipDay(endDateTZ.isoWeekday()) ||
+      isClosedDay(endDateTZ)
+    ) {
+      if (!isSkipDay(endDateTZ.isoWeekday()) && !isClosedDay(endDateTZ)) {
+        addedDays += 1;
+      }
+      endDateTZ.add(1, 'days');
+    }
 
     return moment.utc(endDateTZ).format();
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.55",
+  "version": "1.0.57",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -21,6 +21,7 @@
     "test:getModifierTags": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/item/getModifierTags.test.js",
     "test:createIndirectModifier": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/modifier/createIndirectModifier.test.js",
     "test:conditionsNotMet": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/conditionsNotMet.test.js",
+    "test:pickEndDate": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/pickEndDate.test.js",
     "lint": "eslint --quiet lib/"
   },
   "publishConfig": {
@@ -44,5 +45,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "4341a5b5f555e6148a83ba4dba73bb7c908a02f5"
+  "gitHead": "d7719dca121087e9f10644bcef8ccd76e1271104"
 }