@darkpos/pricing 1.0.40 → 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__/mocks/items/item1Mock.json

@@ -0,0 +1,73 @@
+{
+  "location": {},
+  "status": {
+    "picked": {
+      "value": false,
+      "date": ""
+    },
+    "paid": {
+      "value": false,
+      "date": ""
+    },
+    "tracker": []
+  },
+  "name": "Dummy Pants 1",
+  "description": "Dummy Pants 1",
+  "pieces": 1,
+  "modifiersTotalAmount": 0,
+  "total": 2,
+  "totalPaid": 0,
+  "price": 2,
+  "quantity": 1,
+  "path": ",66da070aac2d4ae39904050f,66da131a81cf1303bc32a2c7,",
+  "notes": [],
+  "serial": null,
+  "sku": "DUN-PAN1",
+  "modifiers": [],
+  "_id": "66ec759cd57e32c3455724a0",
+  "weight": null,
+  "properties": null,
+  "hasInventory": true,
+  "inventoryType": "pull",
+  "category": null,
+  "priceLevels": [
+    {
+      "value": 10,
+      "tags": [
+        "default"
+      ]
+    },
+    {
+      "value": 2,
+      "tags": [
+        "vip"
+      ]
+    },
+    {
+      "value": 10,
+      "tags": [
+        "default",
+        "press only"
+      ]
+    },
+    {
+      "value": 2,
+      "tags": [
+        "vip",
+        "press only"
+      ]
+    }
+  ],
+  "costLevels": [],
+  "itemId": "66da11fdac2d4ae39904465e",
+  "menuRuleId": "66da132381cf1303bc32a2c8",
+  "__typename": "OrderItem",
+  "subTotals": {
+    "_included": 0,
+    "_xincluded": 0,
+    "_direct": 0,
+    "_xdirect": 0,
+    "_simple": 2,
+    "_actual": 2
+  }
+}

package/__TEST__/mocks/items/item2Mock.json

@@ -0,0 +1,73 @@
+{
+  "location": {},
+  "status": {
+    "picked": {
+      "value": false,
+      "date": ""
+    },
+    "paid": {
+      "value": false,
+      "date": ""
+    },
+    "tracker": []
+  },
+  "name": "Dummy Pants 2",
+  "description": "Dummy Pants 2",
+  "pieces": 1,
+  "modifiersTotalAmount": 0,
+  "total": 2,
+  "totalPaid": 0,
+  "price": 2,
+  "quantity": 1,
+  "path": ",66da070aac2d4ae39904050f,66da131a81cf1303bc32a2c7,",
+  "notes": [],
+  "serial": null,
+  "sku": "DUN-PAN2",
+  "modifiers": [],
+  "_id": "66ec759cd57e32c3455724a0",
+  "weight": null,
+  "properties": null,
+  "hasInventory": true,
+  "inventoryType": "pull",
+  "category": null,
+  "priceLevels": [
+    {
+      "value": 10,
+      "tags": [
+        "default"
+      ]
+    },
+    {
+      "value": 2,
+      "tags": [
+        "vip"
+      ]
+    },
+    {
+      "value": 10,
+      "tags": [
+        "default",
+        "press only"
+      ]
+    },
+    {
+      "value": 2,
+      "tags": [
+        "vip",
+        "press only"
+      ]
+    }
+  ],
+  "costLevels": [],
+  "itemId": "66da11fdac2d4ae39904465e",
+  "menuRuleId": "66da132381cf1303bc32a2c8",
+  "__typename": "OrderItem",
+  "subTotals": {
+    "_included": 0,
+    "_xincluded": 0,
+    "_direct": 0,
+    "_xdirect": 0,
+    "_simple": 2,
+    "_actual": 2
+  }
+}

package/__TEST__/mocks/items/item3Mock.json

@@ -0,0 +1,73 @@
+{
+  "location": {},
+  "status": {
+    "picked": {
+      "value": false,
+      "date": ""
+    },
+    "paid": {
+      "value": false,
+      "date": ""
+    },
+    "tracker": []
+  },
+  "name": "Dummy Pants 3",
+  "description": "Dummy Pants 3",
+  "pieces": 1,
+  "modifiersTotalAmount": 0,
+  "total": 2,
+  "totalPaid": 0,
+  "price": 2,
+  "quantity": 1,
+  "path": ",66da070aac2d4ae39904050f,66da131a81cf1303bc32a2c7,",
+  "notes": [],
+  "serial": null,
+  "sku": "DUN-PAN3",
+  "modifiers": [],
+  "_id": "66ec759cd57e32c3455724a0",
+  "weight": null,
+  "properties": null,
+  "hasInventory": true,
+  "inventoryType": "pull",
+  "category": null,
+  "priceLevels": [
+    {
+      "value": 10,
+      "tags": [
+        "default"
+      ]
+    },
+    {
+      "value": 2,
+      "tags": [
+        "vip"
+      ]
+    },
+    {
+      "value": 10,
+      "tags": [
+        "default",
+        "press only"
+      ]
+    },
+    {
+      "value": 2,
+      "tags": [
+        "vip",
+        "press only"
+      ]
+    }
+  ],
+  "costLevels": [],
+  "itemId": "66da11fdac2d4ae39904465e",
+  "menuRuleId": "66da132381cf1303bc32a2c8",
+  "__typename": "OrderItem",
+  "subTotals": {
+    "_included": 0,
+    "_xincluded": 0,
+    "_direct": 0,
+    "_xdirect": 0,
+    "_simple": 2,
+    "_actual": 2
+  }
+}

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/createSuborder.test.js

@@ -0,0 +1,36 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+const orderMock = require('../modifier/mocks/orderMock.json');
+const item1Mock = require('../mocks/items/item1Mock.json');
+const item2Mock = require('../mocks/items/item2Mock.json');
+const item3Mock = require('../mocks/items/item3Mock.json');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+describe('Create suborder', () => {
+  test('Create a suborder with one order', () => {
+    const subOrders = pricingService.order.createSuborder(orderMock);
+    const order = {
+      ...orderMock,
+      orders: subOrders,
+    };
+    expect(order.orders).toHaveLength(1);
+    expect(subOrders).toHaveLength(1);
+  });
+
+  test('Create suborder with multiple items in the order', () => {
+    const multipleItemsOrderMock = {
+      ...orderMock,
+      items: [item1Mock, item2Mock, item3Mock], // assuming items is an array of items
+    };
+    const subOrders = pricingService.order.createSuborder(
+      multipleItemsOrderMock
+    );
+
+    expect(subOrders[0].items).toHaveLength(3); // Suborders should match number of items
+  });
+});

package/__TEST__/order/getSuborder.test.js

@@ -0,0 +1,89 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+const orderMock = require('../modifier/mocks/orderMock.json');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+const mockItem = {
+  location: {},
+  status: {
+    picked: {
+      value: false,
+      date: '',
+    },
+    paid: {
+      value: false,
+      date: '',
+    },
+    tracker: [],
+  },
+  name: 'Andre Pants 2',
+  description: 'Andre Pants 2',
+  pieces: 1,
+  modifiersTotalAmount: 0,
+  total: 2,
+  totalPaid: 0,
+  price: 2,
+  quantity: 1,
+  path: ',66da070aac2d4ae39904050f,66da131a81cf1303bc32a2c7,',
+  notes: [],
+  serial: null,
+  sku: 'AND-PAN2',
+  modifiers: [],
+  _id: '66ec759cd57e32c3455724a0',
+  weight: null,
+  properties: null,
+  hasInventory: true,
+  inventoryType: 'pull',
+  category: null,
+  priceLevels: [
+    {
+      value: 10,
+      tags: ['default'],
+    },
+    {
+      value: 2,
+      tags: ['vip'],
+    },
+    {
+      value: 10,
+      tags: ['default', 'press only'],
+    },
+    {
+      value: 2,
+      tags: ['vip', 'press only'],
+    },
+  ],
+  costLevels: [],
+  itemId: '66da11fdac2d4ae39904465e',
+  menuRuleId: '66da132381cf1303bc32a2c8',
+  __typename: 'OrderItem',
+  subTotals: {
+    _included: 0,
+    _xincluded: 0,
+    _direct: 0,
+    _xdirect: 0,
+    _simple: 2,
+    _actual: 2,
+  },
+};
+
+describe('Get sub order', () => {
+  test('Get a suborder with one item', () => {
+    const order = orderMock;
+    const create = pricingService.order.getSuborder({ order });
+    const newSubOrders = [create(order.items, 1)];
+    expect(newSubOrders).toHaveLength(1);
+  });
+  test('Get a suborder with multiple items', () => {
+    const order = orderMock;
+    const create = pricingService.order.getSuborder({ order });
+    order.items = [...order.items, mockItem];
+    const newSubOrders = [create(order.items, 2)];
+    expect(newSubOrders).toHaveLength(1);
+  });
+});

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/createSuborder.js

@@ -0,0 +1,17 @@
+module.exports = ({ actions }) =>
+  function createSuborder(order) {
+    const create = actions.getSuborder({ order });
+    let subOrders = order.orders || [];
+    const newSubOrders = [create(order.items, 1)];
+    subOrders = [...subOrders, ...newSubOrders].map((subOrder, idx) => ({
+      ...subOrder,
+      displayId: `${order.displayId}-${idx + 1}`,
+    }));
+
+    subOrders = actions.spreadModifiers({
+      parentOrder: order,
+      subOrders,
+    });
+
+    return subOrders;
+  };

package/lib/order/getSuborder.js

@@ -0,0 +1,49 @@
+module.exports = ({ utils, _, settings }) => {
+  const orderSettings = _.get(settings, 'order');
+  const { date, helpers } = utils;
+  const noteDefaults = {
+    message: '',
+    attributes: [],
+    date: date.toISOString(),
+    user: null,
+    url: '',
+    __typename: 'Note',
+  };
+  const getSubOrder =
+    ({ order }) =>
+    (items, index) => {
+      let displayId = '';
+      if (orderSettings.allowSuborder)
+        displayId = `${order.displayId}-${index}`;
+      else if (index === 1) displayId = order.displayId;
+
+      return {
+        ...order,
+        _id: helpers.getObjectID(),
+        displayId,
+        discount: 0,
+        tax: 0,
+        totalPaid: 0,
+        total: 0,
+        status: {
+          order: 'open',
+          delivery: order.status.delivery,
+          detailed: order.status.detailed,
+          fullyPaid: false,
+          fullyPicked: false,
+        },
+        parentId: orderSettings.allowSuborder ? order._id : null,
+        items,
+        modifiers: [],
+        notes: [
+          ...(order.notes || []),
+          {
+            ...noteDefaults,
+            message: `Suborder from ${order.displayId}`, // ask about this message
+          },
+        ],
+      };
+    };
+
+  return getSubOrder;
+};

package/lib/order/index.js

@@ -86,6 +86,8 @@ const validateFixedModifiersTotal = require('./validateFixedModifiersTotal');
 const markModifiersAsLocked = require('./markModifiersAsLocked');
 const removeModifiers = require('./removeModifiers');
 const addModifiers = require('./addModifiers');
+const createSuborder = require('./createSuborder');
+const getSuborder = require('./getSuborder');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -184,6 +186,8 @@ const orderActions = (deps = {}) => {
     markModifiersAsLocked: markModifiersAsLocked(innerDeps),
     removeModifiers: removeModifiers(innerDeps),
     addModifiers: addModifiers(innerDeps),
+    createSuborder: createSuborder(innerDeps),
+    getSuborder: getSuborder(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

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

@@ -1,14 +1,5 @@
-module.exports = ({ utils, _, itemActions, modifierActions, settings }) => {
-  const orderSettings = _.get(settings, 'order');
-  const { date, helpers } = utils;
-  const noteDefaults = {
-    message: '',
-    attributes: [],
-    date: date.toISOString(),
-    user: null,
-    url: '',
-    __typename: 'Note',
-  };
+module.exports = ({ utils, _, actions, itemActions, modifierActions }) => {
+  const { helpers } = utils;
 
   const joinItemQuantity = orders =>
     orders.map(order => {
@@ -39,42 +30,6 @@ module.exports = ({ utils, _, itemActions, modifierActions, settings }) => {
       return { ...order, items };
     });
 
-  const getOrder =
-    ({ order, name }) =>
-    (items, index) => {
-      let displayId = '';
-      if (orderSettings.allowSuborder)
-        displayId = `${order.displayId}-${index}`;
-      else if (index === 1) displayId = order.displayId;
-
-      return {
-        ...order,
-        _id: helpers.getObjectID(),
-        displayId,
-        discount: 0,
-        tax: 0,
-        totalPaid: 0,
-        total: 0,
-        status: {
-          order: 'open',
-          delivery: order.status.delivery,
-          detailed: order.status.detailed,
-          fullyPaid: false,
-          fullyPicked: false,
-        },
-        parentId: orderSettings.allowSuborder ? order._id : null,
-        items,
-        modifiers: [],
-        notes: [
-          ...(order.notes || []),
-          {
-            ...noteDefaults,
-            message: `Split from ${order.displayId}, for department ${name}`,
-          },
-        ],
-      };
-    };
-
   const getDepartmentName = item => {
     const deps = itemActions.getDepartmentModifiers(item);
     return (deps.length && deps[0].name) || 'other';
@@ -91,7 +46,7 @@ module.exports = ({ utils, _, itemActions, modifierActions, settings }) => {
 
     orders.forEach(each => {
       const [name, newItems] = each;
-      const create = getOrder({ order, name });
+      const create = actions.getSuborder({ order, name });
       // Assuming there is one department in the item
       const department = itemActions.getDepartmentModifiers(newItems[0])[0];
       const departmentName = getDepartmentName(newItems[0]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.40",
+  "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": "da5bee1f9a5c7e67c1776be8c31b093551d5df0d"
+  "gitHead": "60a1eef3eb458c750cda95b701904c8ea7e68157"
 }