@darkpos/pricing 1.0.73 → 1.0.76

package/__TEST__/item/unpick.item.test.js

@@ -0,0 +1,21 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+describe('Item actions - unpick item', () => {
+  test('unpick item', () => {
+    const orderItem = {
+      price: 30,
+      quantity: 2,
+      status: { picked: { value: true, date: new Date() } },
+    };
+
+    const newItem = pricingService.item.unpickItem(orderItem);
+    expect(newItem.status.picked).toStrictEqual({ value: false, date: '' });
+  });
+});

package/__TEST__/modifier/hasModifier.test.js

@@ -1751,4 +1751,39 @@ describe('hasModifier Function', () => {
 
     expect(result2).toBe(true);
   });
+
+  test('hasModifier, matching by spreadFrom', () => {
+    const groupMod = {
+      _id: 'groupMod10',
+      attributes: ['group'],
+      properties: {
+        group: {},
+      },
+      modifierId: 'abcd123',
+    };
+
+    const spreadedManualModifier = {
+      _id: 'abc',
+      name: 'related item abc',
+      itemId: 'abc',
+      properties: {
+        spreadFrom: groupMod.modifierId,
+      },
+    };
+
+    const item = {
+      _id: 1,
+      itemId: 'ab',
+      modifiers: [groupMod, spreadedManualModifier],
+      price: 500,
+      total: 10000,
+    };
+
+    const result = pricingService.item.hasModifier({
+      item,
+      modifier: groupMod,
+    });
+
+    expect(result).toBe(true);
+  });
 });

package/__TEST__/modifier.test.js

@@ -680,4 +680,197 @@ describe('Modifier actions', () => {
       })
     );
   });
+
+  describe('getManualModifiers', () => {
+    it('should generate manual modifiers correctly for dry cleaning tags', () => {
+      const modifier = {
+        _id: 'abc123',
+        name: 'Base Modifier',
+        group: 'colorGroup1',
+        properties: {
+          group: {
+            manualModifiers: 'Red Tag, White Shirt, White Shirt , Blue Label',
+          },
+        },
+      };
+
+      const relatedModifiers = [{ name: 'White Shirt' }];
+
+      const result = pricingService.modifier.getManualModifiers({
+        modifier,
+        relatedModifiers,
+      });
+
+      expect(result).toHaveLength(2);
+      expect(result).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            name: 'Red Tag',
+            direct: true,
+            group: 'colorGroup1',
+            properties: {
+              isManual: true,
+            },
+            _id: 'ead6eb247a93bca8f802f9b2',
+          }),
+          expect.objectContaining({
+            name: 'Blue Label',
+            direct: true,
+            group: 'colorGroup1',
+            properties: {
+              isManual: true,
+            },
+            _id: '4e23edf8fa734884f4618003',
+          }),
+        ])
+      );
+    });
+
+    it('should return an empty array if no manual modifiers are present', () => {
+      const modifier = {
+        _id: 'xyz789',
+        properties: {
+          group: {
+            manualModifiers: '',
+          },
+        },
+      };
+
+      const result = pricingService.modifier.getManualModifiers({
+        modifier,
+        relatedModifiers: [],
+      });
+      expect(result).toEqual([]);
+    });
+
+    it('should return an empty array if required fields are missing', () => {
+      expect(
+        pricingService.modifier.getManualModifiers({ modifier: null })
+      ).toEqual([]);
+      expect(
+        pricingService.modifier.getManualModifiers({ modifier: {} })
+      ).toEqual([]);
+    });
+  });
+
+  describe('spreadSingleGroupModifiers', () => {
+    it('should spread the modifiers from a group, including its manual modifiers', () => {
+      const modifier = {
+        _id: 'abc123',
+        name: 'Base Modifier',
+        group: 'colorGroup1',
+        attributes: ['group'],
+        properties: {
+          group: {
+            manualModifiers: 'Red Tag, White Shirt, White Shirt , Blue Label',
+          },
+        },
+      };
+
+      const result = pricingService.modifier.spreadSingleGroupModifiers([
+        modifier,
+      ]);
+
+      expect(result).toStrictEqual([
+        {
+          name: 'Red Tag',
+          _id: 'ead6eb247a93bca8f802f9b2',
+          direct: true,
+          group: 'colorGroup1',
+          properties: { isManual: true, spreadFrom: 'abc123' },
+        },
+        {
+          name: 'White Shirt',
+          _id: '4e23edf8fa734884f4618003',
+          direct: true,
+          group: 'colorGroup1',
+          properties: { isManual: true, spreadFrom: 'abc123' },
+        },
+        {
+          name: 'Blue Label',
+          _id: '94b02ee7ba009b09a913a786',
+          direct: true,
+          group: 'colorGroup1',
+          properties: { isManual: true, spreadFrom: 'abc123' },
+        },
+      ]);
+    });
+
+    it('should not spread the modifiers from a group, as there are other modifiers with the same group', () => {
+      const modifier = {
+        _id: 'abc123',
+        name: 'Base Modifier',
+        group: 'colorGroup1',
+        attributes: ['group'],
+        properties: {
+          group: {
+            manualModifiers: 'Red Tag, White Shirt, White Shirt , Blue Label',
+          },
+        },
+      };
+
+      const otherModifier = {
+        _id: 'bcd123',
+        name: 'other Modifier',
+        group: 'colorGroup1',
+      };
+
+      const result = pricingService.modifier.spreadSingleGroupModifiers([
+        modifier,
+        otherModifier,
+      ]);
+
+      expect(result).toStrictEqual([modifier, otherModifier]);
+    });
+
+    it('should spread the modifiers from a group, as there are  no other modifiers with the same group', () => {
+      const modifier = {
+        _id: 'abc123',
+        name: 'Base Modifier',
+        group: 'colorGroup1',
+        attributes: ['group'],
+        properties: {
+          group: {
+            manualModifiers: 'Red Tag, White Shirt, White Shirt , Blue Label',
+          },
+        },
+      };
+
+      const otherModifier = {
+        _id: 'bcd123',
+        name: 'other Modifier',
+        group: 'Repair',
+      };
+
+      const result = pricingService.modifier.spreadSingleGroupModifiers([
+        modifier,
+        otherModifier,
+      ]);
+
+      expect(result).toStrictEqual([
+        {
+          name: 'Red Tag',
+          _id: 'ead6eb247a93bca8f802f9b2',
+          direct: true,
+          group: 'colorGroup1',
+          properties: { isManual: true, spreadFrom: 'abc123' },
+        },
+        {
+          name: 'White Shirt',
+          _id: '4e23edf8fa734884f4618003',
+          direct: true,
+          group: 'colorGroup1',
+          properties: { isManual: true, spreadFrom: 'abc123' },
+        },
+        {
+          name: 'Blue Label',
+          _id: '94b02ee7ba009b09a913a786',
+          direct: true,
+          group: 'colorGroup1',
+          properties: { isManual: true, spreadFrom: 'abc123' },
+        },
+        { _id: 'bcd123', name: 'other Modifier', group: 'Repair' },
+      ]);
+    });
+  });
 });

package/__TEST__/order/unpick.order.test.js

@@ -0,0 +1,97 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+describe('Order actions - unpick order', () => {
+  test('unpick items in parent order', () => {
+    const orderItem = {
+      price: 30,
+      quantity: 2,
+      status: { picked: { value: true, date: new Date() } },
+    };
+    const order = { items: [orderItem], status: { fullyPicked: true } };
+    const newOrder = pricingService.order.unpickOrder(order);
+    expect(newOrder.status.fullyPicked).toBe(false);
+    newOrder.items.map(item =>
+      expect(item.status.picked).toStrictEqual({ value: false, date: '' })
+    );
+  });
+  test('unpick 10 items in parent order', () => {
+    const orderItem = {
+      price: 30,
+      quantity: 2,
+      status: { picked: { value: true, date: new Date() } },
+    };
+    const order = {
+      status: { fullyPicked: true },
+      items: [
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+      ],
+    };
+    const newOrder = pricingService.order.unpickOrder(order);
+    expect(newOrder.status.fullyPicked).toBe(false);
+    newOrder.items.map(item =>
+      expect(item.status.picked).toStrictEqual({ value: false, date: '' })
+    );
+  });
+  test('unpick items in parent order with items that are not picked', () => {
+    const orderItem = {
+      price: 30,
+      quantity: 2,
+      status: { picked: { value: true, date: new Date() } },
+    };
+    const orderItemNotPicked = {
+      price: 30,
+      quantity: 2,
+      status: { picked: { value: false, date: '' } },
+    };
+    const order = {
+      items: [orderItem, orderItemNotPicked],
+      status: { fullyPicked: true },
+    };
+    const newOrder = pricingService.order.unpickOrder(order);
+    expect(newOrder.status.fullyPicked).toBe(false);
+    newOrder.items.map(item =>
+      expect(item.status.picked).toStrictEqual({ value: false, date: '' })
+    );
+  });
+
+  test('unpick items in parent order with items and suborder with items picked', () => {
+    const orderItem = {
+      price: 30,
+      quantity: 2,
+      status: { picked: { value: true, date: new Date() } },
+    };
+
+    const subOrder = { items: [orderItem], status: { fullyPicked: true } };
+    const order = {
+      items: [orderItem],
+      orders: [subOrder],
+      status: { fullyPicked: true },
+    };
+    const newOrder = pricingService.order.unpickOrder(order);
+    newOrder.items.map(item =>
+      expect(item.status.picked).toStrictEqual({ value: false, date: '' })
+    );
+    newOrder.orders.map(_order => {
+      expect(_order.status.fullyPicked).toBe(false);
+      return _order.items.map(item =>
+        expect(item.status.picked).toStrictEqual({ value: false, date: '' })
+      );
+    });
+  });
+});

package/lib/index.js

@@ -2,6 +2,8 @@ const utils = require('@darkpos/utils');
 const _ = require('lodash');
 const moment = require('moment-timezone');
 /** services  */
+const sha256 = require('crypto-js/sha256');
+
 const makeStoreActions = require('./store');
 const makeItemActions = require('./item');
 const makeOrderActions = require('./order');
@@ -18,6 +20,7 @@ module.exports = session => {
     utils,
     localization,
     _,
+    sha256,
     moment,
     constants,
   };

package/lib/item/getPipeModifiers.js

@@ -3,7 +3,7 @@ module.exports = ({ modifierActions }) =>
     if (!item || !Array.isArray(item.modifiers)) return [];
     return item.modifiers.filter(
       modifier =>
-        modifierActions.isGroupOfModifiers(modifier) &&
+        modifierActions.isGroup(modifier) &&
         modifierActions.isRequired(modifier) &&
         modifierActions.enableAutoPopup(modifier)
     );

package/lib/item/getRelatedModifiers.js

@@ -0,0 +1,14 @@
+module.exports = ({ modifierActions }) =>
+  function getRelatedModifiers({ item }) {
+    if (!item || !Array.isArray(item.modifiers)) return [];
+
+    const relatedModifiers = [];
+
+    item.modifiers.forEach(itemMod => {
+      if (modifierActions.isRelatedModifier(itemMod)) {
+        relatedModifiers.push(itemMod);
+      }
+    });
+
+    return relatedModifiers;
+  };

package/lib/item/hasModifier.js

@@ -2,29 +2,35 @@ module.exports = ({ modifierActions }) =>
   function hasModifier({ item, modifier, relatedItems }) {
     if (!item || !modifier || !item.modifiers) return false;
 
-    const isGroupPath = groupPath =>
-      groupPath &&
-      (groupPath.includes(modifier.modifierId) ||
-        groupPath.includes(modifier._id));
-
     if (modifierActions.isGroup(modifier)) {
       const matchByRelatedModifier = item.modifiers.some(itemMod => {
         if (
           modifierActions.isGroup(itemMod) ||
           !itemMod.properties ||
-          !itemMod.properties.groupPath
+          (!itemMod.properties.groupPath && !itemMod.properties.spreadFrom)
         )
           return false;
-        return isGroupPath(itemMod.properties.groupPath);
+        return (
+          modifierActions.isGroupPath({
+            groupPath: itemMod.properties.groupPath,
+            modifier,
+          }) ||
+          modifierActions.isSpreadFrom({
+            spreadFromId: itemMod.properties.spreadFrom,
+            modifier,
+          })
+        );
       });
 
       const matchByRelatedItems =
         !!relatedItems &&
         modifierActions.isGroup(modifier) &&
         relatedItems.some(relatedItem =>
-          isGroupPath(
-            relatedItem.properties && relatedItem.properties.groupPath
-          )
+          modifierActions.isGroupPath({
+            groupPath:
+              relatedItem.properties && relatedItem.properties.groupPath,
+            modifier,
+          })
         );
 
       return matchByRelatedModifier || matchByRelatedItems;

package/lib/item/index.js

@@ -50,6 +50,8 @@ const getLastLocation = require('./getLastLocation');
 const hasAddModifiers = require('./hasAddModifiers');
 const getAddModifiers = require('./getAddModifiers');
 const getRelatedItems = require('./getRelatedItems');
+const getRelatedModifiers = require('./getRelatedModifiers');
+const unpickItem = require('./unpick');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -113,6 +115,8 @@ const itemActions = (deps = {}) => {
     hasAddModifiers: hasAddModifiers(innerDeps),
     getAddModifiers: getAddModifiers(innerDeps),
     getRelatedItems: getRelatedItems(innerDeps),
+    getRelatedModifiers: getRelatedModifiers(innerDeps),
+    unpickItem: unpickItem(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/removeModifier.js

@@ -15,7 +15,7 @@ module.exports = ({ modifierActions, _, actions }) => {
 
     if (!isValid(itemModifiers, modifier)) return item;
 
-    const addModifiers = modifierActions.getRelatedModifiers({
+    const addModifiers = modifierActions.getAddModifiers({
       modifier,
     });
 

package/lib/item/unpick.js

@@ -0,0 +1,15 @@
+module.exports = () =>
+  function unpickItem(item) {
+    if (!item) return item;
+    const nextItem = { ...item };
+    if (nextItem.status) {
+      nextItem.status = {
+        ...nextItem.status,
+        picked: {
+          value: false,
+          date: '',
+        },
+      };
+    }
+    return nextItem;
+  };

package/lib/modifier/getAddModifiers.js

@@ -0,0 +1,6 @@
+module.exports = () =>
+  function getAddModifiers({ modifier }) {
+    if (!modifier || !modifier.addModifiers) return [];
+
+    return modifier.addModifiers;
+  };

package/lib/modifier/getItemModifiers.js

@@ -11,7 +11,7 @@ module.exports = ({ actions }) =>
 
     const relatedModifiers = enabledModifiers
       .map(each =>
-        actions.getRelatedModifiers({
+        actions.getAddModifiers({
           modifier: each,
         })
       )

package/lib/modifier/getManualModifiers.js

@@ -0,0 +1,64 @@
+module.exports = ({ sha256 }) => {
+  const csvToArray = input =>
+    input
+      .split(',')
+      .map(item => item.trim())
+      .filter(item => item !== '');
+
+  const cleanCSV = input => {
+    if (!input) return '';
+    return Array.from(
+      new Set(
+        input
+          .split(',')
+          .map(item => item.trim())
+          .filter(item => item !== '')
+      )
+    ).join(',');
+  };
+
+  return function getManualModifiers({ modifier, relatedModifiers }) {
+    if (
+      !modifier ||
+      !modifier.properties ||
+      !modifier.properties.group ||
+      !modifier.properties.group.manualModifiers
+    )
+      return [];
+
+    const otherModifiers = Array.isArray(relatedModifiers)
+      ? relatedModifiers
+      : [];
+
+    const manualModifiersCsv = modifier.properties.group.manualModifiers;
+    const modifiers = [];
+
+    if (manualModifiersCsv) {
+      const manualModifiersNames = csvToArray(
+        cleanCSV(manualModifiersCsv)
+      ).filter(modName => otherModifiers.every(mod => mod.name !== modName));
+
+      modifiers.push(
+        ...manualModifiersNames.map((each, index) => {
+          const hash = sha256(`${index}-${modifier._id}`).toString();
+
+          const _id = hash.substring(0, 24);
+
+          const manualModifier = {
+            name: each,
+            _id,
+            direct: true,
+            group: modifier.group,
+            properties: {
+              isManual: true,
+            },
+          };
+
+          return manualModifier;
+        })
+      );
+    }
+
+    return modifiers;
+  };
+};

package/lib/modifier/getRelatedModifiers.js

@@ -1,8 +1,28 @@
-module.exports = () =>
-  function getRelatedModifiers({ modifier }) {
-    if (!modifier || !modifier.addModifiers) return [];
+module.exports = ({ actions }) =>
+  function getRelatedModifiers({ groupModifier, modifiers }) {
+    if (!actions.isGroup(groupModifier) || !Array.isArray(modifiers)) return [];
 
-    const relatedModifiers = modifier.addModifiers;
+    const relatedModifiers = [];
+
+    const otherModifiers = modifiers.filter(
+      mod =>
+        !actions.isGroup(mod) && mod._id !== groupModifier._id && mod.properties
+    );
+
+    otherModifiers.forEach(mod => {
+      if (
+        actions.isGroupPath({
+          groupPath: mod.properties.groupPath,
+          modifier: groupModifier,
+        }) ||
+        actions.isSpreadFrom({
+          spreadFromId: mod.properties.spreadFrom,
+          modifier: groupModifier,
+        })
+      ) {
+        relatedModifiers.push(mod);
+      }
+    });
 
     return relatedModifiers;
   };

package/lib/modifier/index.js

@@ -43,7 +43,7 @@ const getPreferences = require('./getPreferences');
 const getPromotionModifiers = require('./getPromotionModifiers');
 const getPromptMessage = require('./getPromptMessage');
 const getProperty = require('./getProperty');
-const getRelatedModifiers = require('./getRelatedModifiers');
+const getAddModifiers = require('./getAddModifiers');
 const getRecommendedModifiers = require('./getRecommendedModifiers');
 const getRequiredModifiers = require('./getRequiredModifiers');
 const getSubscriptionItem = require('./getSubscriptionItem');
@@ -114,7 +114,7 @@ const isFixedDiscount = require('./isFixedDiscount');
 const removeLocked = require('./removeLocked');
 const hasItems = require('./hasItems');
 const removeGroupData = require('./removeGroupData');
-const isRelatedModifier = require('./isRelatedModifier');
+const isRelatedModifierById = require('./isRelatedModifierById');
 const getGroupedModifiers = require('./getGroupedModifiers');
 const isOptionsOverride = require('./isOptionsOverride');
 const getGroupedModifierLabels = require('./getGroupedModifierLabels');
@@ -143,6 +143,13 @@ const isFixedOverride = require('./isFixedOverride');
 const isLocked = require('./isLocked');
 const hasAddModifier = require('./hasAddModifier');
 const removeGroupRelations = require('./removeGroupRelations');
+const getManualModifiers = require('./getManualModifiers');
+const shouldSpreadModifier = require('./shouldSpreadModifier');
+const spreadSingleGroupModifiers = require('./spreadSingleGroupModifiers');
+const isGroupPath = require('./isGroupPath');
+const isSpreadFrom = require('./isSpreadFrom');
+const getRelatedModifiers = require('./getRelatedModifiers');
+const isRelatedModifier = require('./isRelatedModifier');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -198,7 +205,7 @@ const modifierActions = (deps = {}) => {
     getPromotionModifiers: getPromotionModifiers(innerDeps),
     getPromptMessage: getPromptMessage(innerDeps),
     getProperty: getProperty(innerDeps),
-    getRelatedModifiers: getRelatedModifiers(innerDeps),
+    getAddModifiers: getAddModifiers(innerDeps),
     getRecommendedModifiers: getRecommendedModifiers(innerDeps),
     getRequiredModifiers: getRequiredModifiers(innerDeps),
     getSubscriptionItem: getSubscriptionItem(innerDeps),
@@ -268,7 +275,7 @@ const modifierActions = (deps = {}) => {
     isAdd: isAdd(innerDeps),
     mutateModifier: mutateModifier(innerDeps),
     removeGroupData: removeGroupData(innerDeps),
-    isRelatedModifier: isRelatedModifier(innerDeps),
+    isRelatedModifierById: isRelatedModifierById(innerDeps),
     getGroupedModifiers: getGroupedModifiers(innerDeps),
     isOptionsOverride: isOptionsOverride(innerDeps),
     getGroupedModifierLabels: getGroupedModifierLabels(innerDeps),
@@ -299,6 +306,13 @@ const modifierActions = (deps = {}) => {
     isLocked: isLocked(innerDeps),
     hasAddModifier: hasAddModifier(innerDeps),
     removeGroupRelations: removeGroupRelations(innerDeps),
+    getManualModifiers: getManualModifiers(innerDeps),
+    shouldSpreadModifier: shouldSpreadModifier(innerDeps),
+    spreadSingleGroupModifiers: spreadSingleGroupModifiers(innerDeps),
+    isGroupPath: isGroupPath(innerDeps),
+    isSpreadFrom: isSpreadFrom(innerDeps),
+    getRelatedModifiers: getRelatedModifiers(innerDeps),
+    isRelatedModifier: isRelatedModifier(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isGroupPath.js

@@ -0,0 +1,8 @@
+module.exports = () =>
+  function isGroupPath({ groupPath, modifier }) {
+    return (
+      groupPath &&
+      (groupPath.includes(modifier.modifierId) ||
+        groupPath.includes(modifier._id))
+    );
+  };

package/lib/modifier/isRelatedModifier.js

@@ -1,13 +1,5 @@
-module.exports = ({ actions }) =>
-  function isRelatedModifier({ _id, modifier }) {
-    if (!modifier || !_id) return false;
-
-    if (actions.isGroupOfModifiers(modifier)) {
-      const relatedModifiers = modifier.properties.group.modifiers;
-      return [actions.removeGroupData({ modifier }), ...relatedModifiers].some(
-        relatedModifier => isRelatedModifier({ _id, modifier: relatedModifier })
-      );
-    }
-
-    return modifier._id === _id || modifier.modifierId === _id;
+module.exports = () =>
+  function isRelatedModifier(modifier) {
+    if (!modifier || !modifier.properties) return false;
+    return !!modifier.properties.groupPath || modifier.properties.spreadFrom;
   };

package/lib/modifier/isRelatedModifierById.js

@@ -0,0 +1,14 @@
+module.exports = ({ actions }) =>
+  function isRelatedModifierById({ _id, modifier }) {
+    if (!modifier || !_id) return false;
+
+    if (actions.isGroupOfModifiers(modifier)) {
+      const relatedModifiers = modifier.properties.group.modifiers;
+      return [actions.removeGroupData({ modifier }), ...relatedModifiers].some(
+        relatedModifier =>
+          isRelatedModifierById({ _id, modifier: relatedModifier })
+      );
+    }
+
+    return modifier._id === _id || modifier.modifierId === _id;
+  };

package/lib/modifier/isSpreadFrom.js

@@ -0,0 +1,7 @@
+module.exports = () =>
+  function isSpreadFrom({ spreadFromId, modifier }) {
+    return (
+      spreadFromId &&
+      (spreadFromId === modifier.modifierId || spreadFromId === modifier._id)
+    );
+  };

package/lib/modifier/shouldSpreadModifier.js

@@ -0,0 +1,10 @@
+module.exports = ({ actions }) =>
+  function shouldSpreadModifier(modifier, all) {
+    return (
+      actions.isGroupOfModifiers(modifier) &&
+      !actions.enableAutoPopup(modifier) &&
+      !actions.isGroupOfItems(modifier) &&
+      modifier.group &&
+      !all.some(m => m._id !== modifier._id && m.group === modifier.group)
+    );
+  };

package/lib/modifier/spreadSingleGroupModifiers.js

@@ -0,0 +1,30 @@
+module.exports = ({ actions }) =>
+  function spreadSingleGroupModifiers(modifiersParam) {
+    const result = [];
+
+    if (!Array.isArray(modifiersParam)) return [];
+
+    modifiersParam.forEach(modifier => {
+      if (actions.shouldSpreadModifier(modifier, modifiersParam)) {
+        const relatedModifiers = actions.getGroupRelatedModifiers({
+          modifier,
+        });
+        const manual = actions.getManualModifiers({
+          modifier,
+          relatedModifiers,
+        });
+
+        const nextModifiers = [...relatedModifiers, ...manual].map(mod => ({
+          ...mod,
+          properties: {
+            ...(mod.properties || {}),
+            spreadFrom: modifier._id,
+          },
+        }));
+        result.push(...nextModifiers);
+      } else {
+        result.push(modifier);
+      }
+    });
+    return result;
+  };

package/lib/order/addItemModifier.js

@@ -249,7 +249,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     // Recursive Rules:
     if (modifierActions.hasAddModifiers(modifier)) {
       const relatedModifiers = modifierActions
-        .getRelatedModifiers({ modifier })
+        .getAddModifiers({ modifier })
         .filter(each => !modifierActions.contains(item.modifiers, each));
 
       item = relatedModifiers.reduce(

package/lib/order/index.js

@@ -38,6 +38,7 @@ const toggleModifier = require('./toggleModifier');
 const voidOrder = require('./void');
 const holdOrder = require('./hold');
 const openOrder = require('./open');
+const unpickOrder = require('./unpick');
 const isDetailed = require('./isDetailed');
 const splitByDepartments = require('./splitByDepartments');
 const autoSplit = require('./autoSplit');
@@ -138,6 +139,7 @@ const orderActions = (deps = {}) => {
     voidOrder: voidOrder(innerDeps),
     holdOrder: holdOrder(innerDeps),
     openOrder: openOrder(innerDeps),
+    unpickOrder: unpickOrder(innerDeps),
     isDetailed: isDetailed(innerDeps),
     splitByDepartments: splitByDepartments(innerDeps),
     autoSplit: autoSplit(innerDeps),

package/lib/order/unpick.js

@@ -0,0 +1,28 @@
+module.exports = ({ itemActions }) =>
+  function unpickOrder(order) {
+    if (!order) return order;
+    const nextOrder = { ...order };
+    if (order.items.length > 0) {
+      const orderItems = [...(order.items || [])].map(item =>
+        itemActions.unpickItem(item)
+      );
+      if (nextOrder.status && nextOrder.status.fullyPicked) {
+        nextOrder.status.fullyPicked = false;
+      }
+      nextOrder.items = orderItems;
+    }
+    if (order.orders && order.orders.length > 0) {
+      const suborderWithItems = order.orders.map(_order => {
+        const nextsubOrder = {
+          ..._order,
+          items: _order.items.map(item => itemActions.unpickItem(item)),
+        };
+        if (nextsubOrder.status && nextsubOrder.status.fullyPicked) {
+          nextsubOrder.status.fullyPicked = false;
+        }
+        return nextsubOrder;
+      });
+      nextOrder.orders = suborderWithItems;
+    }
+    return nextOrder;
+  };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.73",
+  "version": "1.0.76",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -34,6 +34,7 @@
   },
   "dependencies": {
     "@darkpos/utils": "^1.0.11",
+    "crypto-js": "^4.2.0",
     "lodash": "^4.17.21",
     "moment-timezone": "^0.5.34"
   },
@@ -50,5 +51,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "276e28f676960107d60027bc70e22f698e6e124e"
+  "gitHead": "195250ff6ff1f2b38a7c47003006b8d2dcb2048b"
 }