@darkpos/pricing 1.0.41 → 1.0.43

package/__TEST__/item/getItemsModifierDescription.test.js

@@ -0,0 +1,141 @@
+const _ = require('lodash');
+const getItemModifiersDescriptionFunction = require('../../lib/item/getItemModifiersDescription');
+
+describe('getItemModifiersDescription Function', () => {
+  const modifierActions = {
+    isHidden: jest.fn(),
+    isAmountOverride: jest.fn(),
+    isDepartment: jest.fn(),
+    isDirect: jest.fn(),
+    isGroupOfValues: jest.fn(),
+    getSelectedValues: jest.fn(),
+    getGroupedModifiers: jest.fn(),
+    getNotesToModifierTags: jest.fn(),
+  };
+
+  const settings = {
+    order: {
+      groupModifiers: false,
+    },
+  };
+
+  const getItemModifiersDescription = getItemModifiersDescriptionFunction({
+    modifierActions,
+    _,
+    settings,
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should return an empty array if item or modifiers are not provided', () => {
+    const result = getItemModifiersDescription(null);
+    expect(result).toEqual([]);
+  });
+
+  test('should filter and map modifiers correctly', () => {
+    const item = {
+      modifiers: [
+        {
+          _id: 'mod1',
+          name: 'Modifier 1',
+          _computed: { description: 'Desc 1' },
+        },
+        { _id: 'mod2', name: 'Modifier 2' },
+      ],
+    };
+
+    modifierActions.isHidden
+      .mockReturnValueOnce(false)
+      .mockReturnValueOnce(false);
+    modifierActions.isAmountOverride
+      .mockReturnValueOnce(false)
+      .mockReturnValueOnce(false);
+    modifierActions.isDepartment
+      .mockReturnValueOnce(false)
+      .mockReturnValueOnce(false);
+    modifierActions.isDirect
+      .mockReturnValueOnce(true)
+      .mockReturnValueOnce(true);
+    modifierActions.isGroupOfValues
+      .mockReturnValueOnce(false)
+      .mockReturnValueOnce(false);
+    modifierActions.getNotesToModifierTags.mockReturnValueOnce([
+      { label: 'Desc 1', value: 'mod1' },
+    ]);
+
+    const result = getItemModifiersDescription(item);
+
+    expect(result).toEqual([{ label: 'Desc 1', value: 'mod1' }]);
+
+    expect(modifierActions.isHidden).toHaveBeenCalledTimes(2);
+    expect(modifierActions.isAmountOverride).toHaveBeenCalledTimes(2);
+    expect(modifierActions.isDepartment).toHaveBeenCalledTimes(2);
+    expect(modifierActions.isDirect).toHaveBeenCalledTimes(2);
+  });
+
+  test('should handle selected override options in the modifier', () => {
+    const item = {
+      modifiers: [
+        {
+          _id: 'mod1',
+          name: 'Modifier 1',
+          compute: { amount: 100 },
+          properties: { override: { selected: { selectedUnit: 'kg' } } },
+        },
+      ],
+    };
+
+    modifierActions.isHidden.mockReturnValueOnce(false);
+    modifierActions.isAmountOverride.mockReturnValueOnce(false);
+    modifierActions.isDepartment.mockReturnValueOnce(false);
+    modifierActions.isDirect.mockReturnValueOnce(true);
+    modifierActions.getNotesToModifierTags.mockReturnValueOnce([
+      {
+        label: 'Modifier 1 100 kg',
+        value: 'mod1',
+        data: item.modifiers[0],
+        quantity: 0,
+      },
+    ]);
+    const result = getItemModifiersDescription(item);
+
+    expect(result).toEqual([
+      {
+        label: 'Modifier 1 100 kg',
+        value: 'mod1',
+        data: item.modifiers[0],
+        quantity: 0,
+      },
+    ]);
+  });
+
+  test('should group modifiers when groupModifiers setting is true', () => {
+    const item = {
+      modifiers: [
+        {
+          _id: 'mod1',
+          name: 'Modifier 1',
+          _computed: { description: 'Desc 1' },
+        },
+      ],
+    };
+
+    settings.order.groupModifiers = true;
+    modifierActions.isHidden.mockReturnValueOnce(false);
+    modifierActions.isAmountOverride.mockReturnValueOnce(false);
+    modifierActions.isDepartment.mockReturnValueOnce(false);
+    modifierActions.isDirect.mockReturnValueOnce(true);
+    modifierActions.getGroupedModifiers.mockReturnValueOnce([
+      { label: 'Grouped Modifier', value: 'mod1' },
+    ]);
+    modifierActions.getNotesToModifierTags.mockReturnValueOnce([
+      { label: 'Grouped Modifier', value: 'mod1' },
+    ]);
+
+    const result = getItemModifiersDescription(item);
+
+    expect(result).toEqual([{ label: 'Grouped Modifier', value: 'mod1' }]);
+  });
+});

package/__TEST__/modifier/getGroupedModifierLabels.test.js

@@ -0,0 +1,95 @@
+const getGroupedModifierLabelsFunction = require('../../lib/modifier/getGroupedModifierLabels');
+
+describe('getGroupedModifierLabels Function', () => {
+  const actions = {
+    getGroupedModifiers: jest.fn(),
+  };
+
+  const getGroupedModifierLabels = getGroupedModifierLabelsFunction({
+    actions,
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should return an empty array if no modifiers are provided', () => {
+    actions.getGroupedModifiers.mockReturnValueOnce([]);
+
+    const result = getGroupedModifierLabels([]);
+
+    expect(result).toEqual([]);
+    expect(actions.getGroupedModifiers).toHaveBeenCalledWith([]);
+  });
+
+  test('should map modifiers to labels and group them by modifierId', () => {
+    const modifiers = [
+      { name: 'Modifier 1', modifierId: 'mod1' },
+      { name: 'Modifier 2', modifierId: 'mod2' },
+    ];
+
+    const groupedModifiers = [
+      { label: '1 Modifier 1', value: 'mod1', data: modifiers[0], quantity: 1 },
+      { label: '1 Modifier 2', value: 'mod2', data: modifiers[1], quantity: 1 },
+    ];
+
+    actions.getGroupedModifiers.mockReturnValueOnce(groupedModifiers);
+
+    const result = getGroupedModifierLabels(modifiers);
+
+    expect(result).toEqual(['1 Modifier 1', '1 Modifier 2']);
+    expect(actions.getGroupedModifiers).toHaveBeenCalledWith([
+      { label: 'Modifier 1', value: 'mod1', data: modifiers[0], quantity: 1 },
+      { label: 'Modifier 2', value: 'mod2', data: modifiers[1], quantity: 1 },
+    ]);
+  });
+
+  test('should group modifiers with the same modifierId and increment quantity', () => {
+    const modifiers = [
+      { name: 'Modifier 1', modifierId: 'mod1' },
+      { name: 'Modifier 1', modifierId: 'mod1' }, // Same modifierId
+    ];
+
+    const groupedModifiers = [
+      { label: '2 Modifier 1', value: 'mod1', data: modifiers[0], quantity: 2 },
+    ];
+
+    actions.getGroupedModifiers.mockReturnValueOnce(groupedModifiers);
+
+    const result = getGroupedModifierLabels(modifiers);
+
+    expect(result).toEqual(['2 Modifier 1']);
+    expect(actions.getGroupedModifiers).toHaveBeenCalledWith([
+      { label: 'Modifier 1', value: 'mod1', data: modifiers[0], quantity: 1 },
+      { label: 'Modifier 1', value: 'mod1', data: modifiers[1], quantity: 1 },
+    ]);
+  });
+
+  test('should handle a single modifier correctly', () => {
+    const modifiers = [{ name: 'Modifier 1', modifierId: 'mod1' }];
+
+    const groupedModifiers = [
+      { label: '1 Modifier 1', value: 'mod1', data: modifiers[0], quantity: 1 },
+    ];
+
+    actions.getGroupedModifiers.mockReturnValueOnce(groupedModifiers);
+
+    const result = getGroupedModifierLabels(modifiers);
+
+    expect(result).toEqual(['1 Modifier 1']);
+    expect(actions.getGroupedModifiers).toHaveBeenCalledWith([
+      { label: 'Modifier 1', value: 'mod1', data: modifiers[0], quantity: 1 },
+    ]);
+  });
+
+  test('should correctly handle an empty modifiers array', () => {
+    const modifiers = [];
+
+    actions.getGroupedModifiers.mockReturnValueOnce([]);
+
+    const result = getGroupedModifierLabels(modifiers);
+
+    expect(result).toEqual([]);
+    expect(actions.getGroupedModifiers).toHaveBeenCalledWith([]);
+  });
+});

package/__TEST__/modifier/getGroupedModifiers.test.js

@@ -0,0 +1,65 @@
+const getGroupedModifiersFunction = require('../../lib/modifier/getGroupedModifiers');
+
+describe('getGroupedModifiers Function', () => {
+  const getGroupedModifiers = getGroupedModifiersFunction();
+
+  test('should return an empty array if no tags are provided', () => {
+    const result = getGroupedModifiers([]);
+    expect(result).toEqual([]);
+  });
+
+  test('should group modifiers by modifierId and increment quantity', () => {
+    const tags = [
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+      { label: 'Modifier 2', data: { modifierId: 'mod2' }, quantity: 1 },
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+    ];
+
+    const result = getGroupedModifiers(tags);
+
+    expect(result).toEqual([
+      { label: '2 Modifier 1', data: { modifierId: 'mod1' }, quantity: 2 },
+      { label: '1 Modifier 2', data: { modifierId: 'mod2' }, quantity: 1 },
+    ]);
+  });
+
+  test('should correctly handle tags with different modifierIds', () => {
+    const tags = [
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+      { label: 'Modifier 2', data: { modifierId: 'mod2' }, quantity: 1 },
+    ];
+
+    const result = getGroupedModifiers(tags);
+
+    expect(result).toEqual([
+      { label: '1 Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+      { label: '1 Modifier 2', data: { modifierId: 'mod2' }, quantity: 1 },
+    ]);
+  });
+
+  test('should not modify original tags array', () => {
+    const tags = [
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+    ];
+
+    const originalTagsCopy = [...tags];
+
+    getGroupedModifiers(tags);
+
+    expect(tags).toEqual(originalTagsCopy); // Ensure original array is not mutated
+  });
+
+  test('should format the label to include the quantity', () => {
+    const tags = [
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+    ];
+
+    const result = getGroupedModifiers(tags);
+
+    expect(result).toEqual([
+      { label: '2 Modifier 1', data: { modifierId: 'mod1' }, quantity: 2 },
+    ]);
+  });
+});

package/__TEST__/modifier/getNotesToModifierTags.test.js

@@ -0,0 +1,78 @@
+const getNotesToModifierTagsFunction = require('../../lib/modifier/getNotesToModifierTags');
+
+describe('getNotesToModifierTags Function', () => {
+  const getNotesToModifierTags = getNotesToModifierTagsFunction();
+
+  test('should return modifierTags if no notes are provided', () => {
+    const modifierTags = [
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+    ];
+
+    const result = getNotesToModifierTags({ notes: null, modifierTags });
+    expect(result).toEqual(modifierTags);
+  });
+
+  test('should return modifierTags if notes array is empty', () => {
+    const modifierTags = [
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+    ];
+
+    const result = getNotesToModifierTags({ notes: [], modifierTags });
+    expect(result).toEqual(modifierTags);
+  });
+
+  test('should filter out notes that are null or have a url', () => {
+    const notes = [
+      { message: 'Note 1' },
+      { message: 'Note 2', url: 'http://example.com' }, // Should be filtered out
+      null, // Should be filtered out
+    ];
+
+    const modifierTags = [
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+    ];
+
+    const result = getNotesToModifierTags({ notes, modifierTags });
+
+    expect(result).toEqual([
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+      { label: 'Note 1', value: '0', data: { message: 'Note 1' }, quantity: 1 },
+    ]);
+  });
+
+  test('should map notes to noteTags and append to modifierTags', () => {
+    const notes = [{ message: 'Note 1' }, { message: 'Note 2' }];
+
+    const modifierTags = [
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+    ];
+
+    const result = getNotesToModifierTags({ notes, modifierTags });
+
+    expect(result).toEqual([
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+      { label: 'Note 1', value: '0', data: { message: 'Note 1' }, quantity: 1 },
+      { label: 'Note 2', value: '1', data: { message: 'Note 2' }, quantity: 1 },
+    ]);
+  });
+
+  test('should handle case where notes contain falsy values', () => {
+    const notes = [null, undefined, { message: 'Valid Note' }];
+
+    const modifierTags = [
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+    ];
+
+    const result = getNotesToModifierTags({ notes, modifierTags });
+
+    expect(result).toEqual([
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+      {
+        label: 'Valid Note',
+        value: '0',
+        data: { message: 'Valid Note' },
+        quantity: 1,
+      },
+    ]);
+  });
+});

package/__TEST__/modifier/isOptionsOverride.test.js

@@ -0,0 +1,46 @@
+const isOptionsOverrideFunction = require('../../lib/modifier/isOptionsOverride');
+
+describe('isOptionsOverride Function', () => {
+  const isOptionsOverride = isOptionsOverrideFunction();
+
+  test('should return false when no modifier is provided', () => {
+    const result = isOptionsOverride(null);
+    expect(result).toBe(false);
+  });
+
+  test('should return false when modifier does not have properties', () => {
+    const modifier = { someKey: 'someValue' };
+    const result = isOptionsOverride(modifier);
+    expect(result).toBe(false);
+  });
+
+  test('should return false when modifier properties do not have override', () => {
+    const modifier = { properties: {} };
+    const result = isOptionsOverride(modifier);
+    expect(result).toBe(false);
+  });
+
+  test('should return false when override has no options', () => {
+    const modifier = {
+      properties: {
+        override: {
+          options: [],
+        },
+      },
+    };
+    const result = isOptionsOverride(modifier);
+    expect(result).toBe(false);
+  });
+
+  test('should return true when override has options', () => {
+    const modifier = {
+      properties: {
+        override: {
+          options: ['option1', 'option2'],
+        },
+      },
+    };
+    const result = isOptionsOverride(modifier);
+    expect(result).toBe(true);
+  });
+});

package/__TEST__/order/pickEndDate.test.js

@@ -56,8 +56,8 @@ describe('pickEndDate function', () => {
 
     const expectedDate = now
       .clone()
-      .add(2, 'days')
-      .set({ hour: 17, minute: 0, second: 0 })
+      .add(3, 'days')
+      .set({ hour: 0, minute: 0, second: 0 })
       .utc()
       .format();
 
@@ -113,7 +113,7 @@ describe('pickEndDate function', () => {
     const expectedDate = now
       .clone()
       .add(2, 'days') // Skips the closed Wednesday, goes to Thursday
-      .set({ hour: 17, minute: 0, second: 0 })
+      .set({ hour: 0, minute: 0, second: 0 })
       .utc()
       .format();
 

package/lib/item/getItemModifiersDescription.js

@@ -1,22 +1,54 @@
-module.exports = ({ modifierActions }) =>
+module.exports = ({ modifierActions, _, settings }) =>
   function getItemModifiersDescription(item) {
+    const groupModifiers =
+      settings && settings.order && settings.order.groupModifiers;
     if (!item || !Array.isArray(item.modifiers)) return [];
-    const description = item.modifiers
+    let description = item.modifiers
       .filter(
         each =>
           !modifierActions.isHidden(each) &&
           !modifierActions.isAmountOverride(each) &&
+          !modifierActions.isDepartment(each) &&
           modifierActions.isDirect(each)
       )
       .map(modifier => {
-        const { name } = modifier;
+        const { name, _id, compute = {} } = modifier;
         let label = name;
         if (modifierActions.isGroupOfValues(modifier))
           label = modifierActions.getSelectedValues(modifier) || label;
+        const selectedOverrideOptions = _.get(
+          modifier,
+          'properties.override.selected'
+        );
+        if (
+          modifier &&
+          !modifier.included &&
+          modifier._computed &&
+          modifier._computed.description
+        ) {
+          label = modifier._computed.description;
+        }
 
-        return label;
-      })
-      .join(', ');
+        const modifierValue = {
+          label,
+          value: _id,
+          data: modifier,
+          quantity: 1,
+        };
 
-    return description;
+        if (selectedOverrideOptions) {
+          modifierValue.label = `${name} ${compute.amount} ${selectedOverrideOptions.selectedUnit}`;
+          modifierValue.quantity = 0;
+        }
+        return modifierValue;
+      });
+    if (groupModifiers) {
+      description = modifierActions.getGroupedModifiers(description);
+    }
+
+    const descriptions = modifierActions.getNotesToModifierTags({
+      notes: item.notes,
+      modifierTags: description,
+    });
+    return descriptions;
   };

package/lib/modifier/getGroupedModifierLabels.js

@@ -0,0 +1,10 @@
+module.exports = ({ actions }) =>
+  function getGroupedModifierLabels(modifiers) {
+    const gModifiers = modifiers.map(modifier => ({
+      label: modifier.name,
+      value: modifier.modifierId,
+      data: modifier,
+      quantity: 1,
+    }));
+    return actions.getGroupedModifiers(gModifiers).map(tag => tag.label);
+  };

package/lib/modifier/getGroupedModifiers.js

@@ -0,0 +1,21 @@
+module.exports = () =>
+  function getGroupedModifiers(tags) {
+    return tags
+      .reduce((acc, curr) => {
+        const found = acc.find(
+          item => item.data.modifierId === curr.data.modifierId
+        );
+
+        if (found) {
+          found.quantity += 1;
+        } else {
+          acc.push({ ...curr });
+        }
+
+        return acc;
+      }, [])
+      .map(tag => ({
+        ...tag,
+        label: `${tag.quantity} ${tag.label}`,
+      }));
+  };

package/lib/modifier/getNotesToModifierTags.js

@@ -0,0 +1,21 @@
+module.exports = () =>
+  function getNotesToModifierTags({ notes, modifierTags }) {
+    let noteTags = [];
+    if (notes && notes.length > 0) {
+      noteTags =
+        notes
+          .filter(Boolean)
+          .filter(item => item && !item.url)
+          .map((note, index) => {
+            const { message } = note;
+            return {
+              label: message,
+              value: index.toString(),
+              data: note,
+              quantity: 1,
+            };
+          }) || [];
+    }
+
+    return modifierTags.concat(noteTags);
+  };

package/lib/modifier/index.js

@@ -129,6 +129,10 @@ const isFixedDiscount = require('./isFixedDiscount');
 const removeLocked = require('./removeLocked');
 const hasItems = require('./hasItems');
 const getLockedModifiers = require('./getLockedModifiers');
+const getGroupedModifiers = require('./getGroupedModifiers');
+const getNotesToModifierTags = require('./getNotesToModifierTags');
+const isOptionsOverride = require('./isOptionsOverride');
+const getGroupedModifierLabels = require('./getGroupedModifierLabels');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -269,6 +273,10 @@ const modifierActions = (deps = {}) => {
     isFee: isFee(innerDeps),
     isAdd: isAdd(innerDeps),
     mutateModifier: mutateModifier(innerDeps),
+    getGroupedModifiers: getGroupedModifiers(innerDeps),
+    getNotesToModifierTags: getNotesToModifierTags(innerDeps),
+    isOptionsOverride: isOptionsOverride(innerDeps),
+    getGroupedModifierLabels: getGroupedModifierLabels(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isOptionsOverride.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function isOptionsOverride(modifier) {
+    if (!modifier || !modifier.properties || !modifier.properties.override)
+      return false;
+    return (
+      modifier.properties.override.options &&
+      modifier.properties.override.options.length > 0
+    );
+  };

package/lib/order/pickEndDate.js

@@ -23,42 +23,39 @@ module.exports = ({ settings, _, moment }) => {
 
     const todayTZ = moment().tz(timezone);
     let endDateTZ = todayTZ.clone();
-
     const closedDays = getClosedDays();
-
+    const todayHours = todayTZ.get('hours');
+    const todayMinutes = todayTZ.get('minutes');
     if (
-      (cutHour && todayTZ.get('hours') > cutHour.hour) ||
-      (todayTZ.get('hours') >= cutHour.hour &&
-        todayTZ.get('minutes') > cutHour.minute)
+      (cutHour && todayHours > cutHour.hour) ||
+      (todayHours >= cutHour.hour && todayMinutes > cutHour.minute)
     ) {
-      endDateTZ = endDateTZ.add(cutDay, 'days');
+      endDateTZ = endDateTZ.add(cutDay, 'days'); // if the cut day is zero should we add a day based on hours? ask Nabil/Vicky
     }
 
-    let addDaysCounter = 0;
-    // 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;
-      // 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 ||
-        // eslint-disable-next-line no-loop-func
-        !closedDays.some(closedDay => closedDay.date.isSame(endDateTZ, 'day'))
-      ) {
-        // eslint-disable-next-line no-plusplus
-        addDaysCounter++;
+    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
+     */
     if (hour !== undefined) endDateTZ.set('hour', hour);
     if (minute !== undefined) endDateTZ.set('minute', minute);
-    endDateTZ.set('second', 0);
+    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');
+      }
+    });
 
     return moment.utc(endDateTZ).format();
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -36,5 +36,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "0ab9e8f6bf59ef671ffb2005712a5ec6f998b36e"
+  "gitHead": "60a1eef3eb458c750cda95b701904c8ea7e68157"
 }