@darkpos/pricing 1.0.131 → 1.0.133

package/__TEST__/item.test.js

@@ -1153,81 +1153,6 @@ describe('Item actions', () => {
     expect(result.items).toMatchObject([item2]);
   });
 
-  test('Should add related item and its related addModifiers to the parent item, then removing that relateditem should also remove the mod from the parent item', () => {
-    const rawRelatedItem1 = {
-      name: 'the related item',
-      _id: '67e2cadd8dcf08ebcc5ef888',
-    };
-
-    const rawRelatedItem2 = {
-      name: 'the 2nd related item',
-      _id: '67e2cadd8dcf08ebcc5ef88a',
-    };
-
-    const groupMod = {
-      _id: '67e2cadd8dcf08ebcc5ef889',
-      name: 'General Repair Department',
-      attributes: ['group'],
-      modifierId: 'mod1',
-      properties: {
-        group: {
-          items: [],
-        },
-      },
-    };
-
-    const parentItem = {
-      name: 'the parent item',
-      modifiers: [groupMod],
-      _id: '67e2cadd8dcf08ebcc5ef887',
-      __typename: 'OrderItem',
-    };
-
-    const relatedItem1 = {
-      ...rawRelatedItem1,
-      properties: {
-        relatedItem: true,
-        parentId: parentItem._id,
-        includeParent: true,
-        addModifiers: [groupMod],
-        groupPath: ',67e2cadd8dcf08ebcc5ef889',
-      },
-      __typename: 'OrderItem',
-    };
-
-    const relatedItem2 = {
-      ...rawRelatedItem2,
-      properties: {
-        relatedItem: true,
-        parentId: parentItem._id,
-        includeParent: true,
-        addModifiers: [groupMod],
-        groupPath: ',67e2cadd8dcf08ebcc5ef889',
-      },
-      __typename: 'OrderItem',
-    };
-    const order = {
-      items: [parentItem, relatedItem1, relatedItem2],
-    };
-
-    const result = pricingService.order.removeItem({
-      order,
-      item: relatedItem2,
-    });
-
-    expect(result.items.length).toBe(2);
-    expect(result.items[0].modifiers.length).toBe(1);
-    expect(result.items[0].modifiers[0].modifierId).toBe('mod1');
-
-    const result2 = pricingService.order.removeItem({
-      order: result,
-      item: relatedItem1,
-    });
-
-    expect(result2.items.length).toBe(1);
-    expect(result2.items[0].modifiers.length).toBe(0);
-  });
-
   test('Should not remove the group modifier if it still hasModifiers', () => {
     const rawRelatedItem1 = {
       name: 'the related item',
@@ -1283,7 +1208,7 @@ describe('Item actions', () => {
       properties: {
         relatedItem: true,
         parentId: parentItem._id,
-        includeParent: true,
+        repairOnly: false,
         addModifiers: [groupMod],
         groupPath: ',67e2cadd8dcf08ebcc5ef889',
       },
@@ -1295,7 +1220,7 @@ describe('Item actions', () => {
       properties: {
         relatedItem: true,
         parentId: parentItem._id,
-        includeParent: true,
+        repairOnly: false,
         addModifiers: [groupMod],
         groupPath: ',67e2cadd8dcf08ebcc5ef889',
       },

package/__TEST__/modifier/getInvalidRequiredModifiers.test.js

@@ -264,7 +264,7 @@ test('getInvalidRequiredModifiers  having related items', () => {
         relatedItem: true,
         parentItemId: '62cdbfd01ee1b4001932821a',
         parentId: '67dc63610c106ab7d481d7dd',
-        includeParent: true,
+        repairOnly: false,
         groupPath: ',67dc63610c106ab7d481d7de',
       },
     },

package/__TEST__/modifier/hasModifier.test.js

@@ -1672,14 +1672,16 @@ describe('hasModifier Function', () => {
           relatedItem: true,
           parentItemId: item.itemId,
           parentId: item._id,
-          includeParent: true,
+          repairOnly: false,
           groupPath: ',groupMod10',
+          removeParentItem: true,
         },
       },
     });
 
     expect(updatedOrder.items.length).toBe(2);
-    expect(updatedOrder.items[1]).toMatchObject({
+
+    const parentItem = {
       _id: 1,
       itemId: 'ab',
       modifiers: [
@@ -1696,7 +1698,8 @@ describe('hasModifier Function', () => {
       ],
       price: 500,
       total: 10000,
-    });
+    };
+    expect(updatedOrder.items[1]).toMatchObject(parentItem);
 
     const result = pricingService.item.hasModifier({
       item: updatedOrder.items[1],
@@ -1717,53 +1720,17 @@ describe('hasModifier Function', () => {
           relatedItem: true,
           parentItemId: item.itemId,
           parentId: item._id,
-          includeParent: false,
+          repairOnly: true,
           groupPath: ',groupMod10',
+          removeParentItem: true,
         },
       },
     });
 
-    expect(updatedOrder2.items.length).toBe(2);
-
-    expect(updatedOrder2.items[1]).toMatchObject({
-      _id: 1,
-      itemId: 'ab',
-      modifiers: [
-        {
-          _id: 'groupMod10',
-          attributes: ['group'],
-          properties: {
-            group: {
-              items: [{ _id: 'abc', name: 'related item abc', itemId: 'abc' }],
-              modifiers: [{ _id: '123', name: 'related mod' }],
-            },
-          },
-          conditions: { valid: true },
-          compute: null,
-          _computed: { amount: 0, description: 'undefined' },
-        },
-      ],
-      price: 0,
-      total: 0,
-      subTotals: {
-        _included: 0,
-        _xincluded: 0,
-        _direct: 0,
-        _xdirect: 0,
-        _actual: 0,
-      },
-    });
-
-    const result2 = pricingService.item.hasModifier({
-      item: updatedOrder2.items[1],
-      modifier: groupMod,
-      relatedItems: pricingService.order.getRelatedItems({
-        order: updatedOrder2,
-        item: updatedOrder2.items[1],
-      }),
-    });
+    expect(updatedOrder2.items.length).toBe(1);
+    expect(updatedOrder2.parentItems.length).toBe(1);
 
-    expect(result2).toBe(true);
+    expect(updatedOrder2.parentItems[0]).toMatchObject(parentItem);
   });
 
   test('hasModifier, matching by spreadFrom', () => {
@@ -1800,4 +1767,107 @@ describe('hasModifier Function', () => {
 
     expect(result).toBe(true);
   });
+
+  test('hasModifier, using only 1 related items and keeping original item', () => {
+    const relatedModItem = {
+      _id: 'abc',
+      name: 'related item abc',
+      itemId: 'abc',
+    };
+    const groupMod = {
+      _id: 'groupMod10',
+      attributes: ['group'],
+      properties: {
+        group: {
+          items: [relatedModItem],
+          modifiers: [
+            {
+              _id: '123',
+              name: 'related mod',
+            },
+          ],
+        },
+      },
+    };
+
+    const item = {
+      _id: 1,
+      itemId: 'ab',
+      modifiers: [groupMod],
+      price: 500,
+      total: 10000,
+    };
+
+    const order = {
+      items: [item],
+      modifiers: [],
+    };
+
+    const { updatedOrder } = pricingService.order.addItem({
+      order,
+      item: {
+        ...relatedModItem,
+        properties: {
+          relatedItem: true,
+          parentItemId: item.itemId,
+          parentId: item._id,
+          repairOnly: false,
+          groupPath: ',groupMod10',
+        },
+      },
+    });
+
+    expect(updatedOrder.items.length).toBe(2);
+
+    const parentItem = {
+      _id: 1,
+      itemId: 'ab',
+      modifiers: [
+        {
+          _id: 'groupMod10',
+          attributes: ['group'],
+          properties: {
+            group: {
+              items: [{ _id: 'abc', name: 'related item abc', itemId: 'abc' }],
+              modifiers: [{ _id: '123', name: 'related mod' }],
+            },
+          },
+        },
+      ],
+      price: 500,
+      total: 10000,
+    };
+    expect(updatedOrder.items[1]).toMatchObject(parentItem);
+
+    const result = pricingService.item.hasModifier({
+      item: updatedOrder.items[1],
+      modifier: groupMod,
+      relatedItems: pricingService.order.getRelatedItems({
+        order: updatedOrder,
+        item: updatedOrder.items[1],
+      }),
+    });
+
+    expect(result).toBe(true);
+
+    const relatedItemtoAdd = {
+      ...relatedModItem,
+      properties: {
+        relatedItem: true,
+        parentItemId: item.itemId,
+        parentId: item._id,
+        repairOnly: false,
+        groupPath: ',groupMod10',
+      },
+    };
+
+    const { updatedOrder: updatedOrder2 } = pricingService.order.addItem({
+      order,
+      item: relatedItemtoAdd,
+    });
+
+    expect(updatedOrder2.items.length).toBe(2);
+    expect(updatedOrder2.items[0].name).toBe('related item abc');
+    expect(updatedOrder2.items[1]).toMatchObject(parentItem);
+  });
 });

package/__TEST__/order/addItem.test.js

@@ -231,7 +231,7 @@ describe('addItem function', () => {
         relatedItem: true,
         parentItemId: updatedOrder.items[0].itemId,
         parentId: updatedOrder.items[0]._id,
-        includeParent: true,
+        repairOnly: false,
         addModifiers: [
           {
             _id: 'mod1',
@@ -270,7 +270,7 @@ describe('addItem function', () => {
         relatedItem: true,
         parentItemId: updatedOrder.items[0].itemId,
         parentId: updatedOrder.items[0]._id,
-        includeParent: true,
+        repairOnly: false,
         addModifiers: [
           {
             _id: 'mod1',

package/__TEST__/order/order.test.js

@@ -3858,4 +3858,79 @@ describe('Order actions', () => {
     );
     expect(newOrder.items[2].total).toEqual(7.44);
   });
+
+  test('Should return same items if there are no related items', () => {
+    const items = [
+      { _id: '1', properties: {} },
+      { _id: '2', properties: {} },
+    ];
+    const parentItems = [{ _id: '10', properties: {} }];
+
+    const result = pricingService.order.getItemsWithParents({
+      items,
+      parentItems,
+    });
+
+    expect(result).toEqual(items);
+  });
+
+  test('Should insert missing parent before first related item', () => {
+    const items = [
+      { _id: '1', properties: {} },
+      { _id: '2', properties: { parentId: '10', relatedItem: true } },
+      { _id: '3', properties: {} },
+    ];
+
+    const parentItems = [
+      { _id: '10', properties: {} },
+      { _id: '11', properties: {} },
+    ];
+
+    const result = pricingService.order.getItemsWithParents({
+      items,
+      parentItems,
+    });
+
+    expect(result).toEqual([
+      { _id: '1', properties: {} },
+      { _id: '10', properties: {} },
+      { _id: '2', properties: { parentId: '10', relatedItem: true } },
+      { _id: '3', properties: {} },
+    ]);
+  });
+
+  test('Should not duplicate parent if already inserted', () => {
+    const items = [
+      { _id: '2', properties: { parentId: '10', relatedItem: true } },
+      { _id: '3', properties: { parentId: '10', relatedItem: true } },
+    ];
+
+    const parentItems = [{ _id: '10', properties: {} }];
+
+    const result = pricingService.order.getItemsWithParents({
+      items,
+      parentItems,
+    });
+
+    const parentCount = result.filter(i => i._id === '10').length;
+    expect(parentCount).toBe(1);
+    expect(result[0]._id).toBe('10');
+  });
+
+  test('Should skip injection if parent already exists in items', () => {
+    const items = [
+      { _id: '10', properties: {} },
+      { _id: '2', properties: { parentId: '10', relatedItem: true } },
+    ];
+    const parentItems = [{ _id: '10', properties: {} }];
+
+    const result = pricingService.order.getItemsWithParents({
+      items,
+      parentItems,
+    });
+
+    const parentCount = result.filter(i => i._id === '10').length;
+    expect(parentCount).toBe(1);
+    expect(result).toEqual(items);
+  });
 });

package/__TEST__/order/split.test.js

@@ -522,6 +522,16 @@ describe('Auto Split', () => {
       __typename: 'Modifier',
     };
 
+    const parentItem = {
+      name: "2pc Men's Suit",
+      modifiers: [dtModifier],
+      _id: '686d62b3e0f59b1de5d93b28',
+      pieces: 2,
+      quantity: 1,
+      weight: 0,
+      properties: {},
+    };
+
     const parentOrder = {
       _id: '686d62ace0f59b1de5d93b27',
 
@@ -535,19 +545,12 @@ describe('Auto Split', () => {
             relatedItem: true,
             parentItemId: '67fea241af24e570c032b319',
             parentId: '686d62b3e0f59b1de5d93b28',
-            includeParent: true,
+            repairOnly: false,
           },
         },
-        {
-          name: "2pc Men's Suit",
-          modifiers: [dtModifier],
-          _id: '686d62b3e0f59b1de5d93b28',
-          pieces: 2,
-          quantity: 1,
-          weight: 0,
-          properties: {},
-        },
+        parentItem,
       ],
+      parentItems: [parentItem],
       modifiers: [],
       status: {},
     };
@@ -644,7 +647,7 @@ describe('Auto Split', () => {
             relatedItem: true,
             parentItemId: '67fea241af24e570c032b319',
             parentId: '686d62b3e0f59b1de5d93b28',
-            includeParent: true,
+            repairOnly: false,
           },
         },
         {

package/lib/item/getSplitDepartment.js

@@ -1,7 +1,7 @@
 module.exports = ({ actions, modifierActions }) =>
-  function getSplitDepartment({ items, item }) {
+  function getSplitDepartment({ parentItems, item }) {
     if (actions.isRelatedItem(item)) {
-      const parentItem = actions.getParentItem(items, item);
+      const parentItem = actions.getParentItem(parentItems, item);
 
       if (parentItem) {
         const parentDeps = actions.getDepartmentModifiers(parentItem);

package/lib/item/hasRelatedItems.js

@@ -0,0 +1,10 @@
+module.exports = ({ actions }) =>
+  function hasRelatedItems({ parentItem, items }) {
+    if (!parentItem || !items) return [];
+
+    return items.some(
+      item =>
+        actions.isRelatedItem(item) &&
+        item.properties.parentId === parentItem._id
+    );
+  };

package/lib/item/index.js

@@ -25,7 +25,7 @@ const getItemsTotalPaid = require('./getItemsTotalPaid');
 const getModifierTags = require('./getModifierTags');
 const isRelatedItem = require('./isRelatedItem');
 const getParentItem = require('./getParentItem');
-const isParentIncluded = require('./isParentIncluded');
+const isRepairOnly = require('./isRepairOnly');
 const hasCreateSubscription = require('./hasCreateSubscription');
 const getItemModifiers = require('./getItemModifiers');
 const getItemsBalance = require('./getItemsBalance');
@@ -46,8 +46,6 @@ const getBasePrice = require('./getBasePrice');
 const validateModifiersByQuantity = require('./validateModifiersByQuantity');
 const getModifiersBySingleValueId = require('./getModifiersBySingleValueId');
 const getLastLocation = require('./getLastLocation');
-const hasAddModifiers = require('./hasAddModifiers');
-const getAddModifiers = require('./getAddModifiers');
 const getRelatedItems = require('./getRelatedItems');
 const getRelatedModifiers = require('./getRelatedModifiers');
 const unpickItem = require('./unpick');
@@ -74,6 +72,11 @@ const isPriceChanged = require('./isPriceChanged');
 const isSerialRequired = require('./isSerialRequired');
 const isSerialLengthValid = require('./isSerialLengthValid');
 const getSerialStatus = require('./getSerialStatus');
+const removeDepartmentModifiers = require('./removeDepartmentModifiers');
+const isRemoveParentItem = require('./isRemoveParentItem');
+const hasRelatedItems = require('./hasRelatedItems');
+const getAddModifiers = require('./getAddModifiers');
+const hasAddModifiers = require('./hasAddModifiers');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -111,7 +114,7 @@ const itemActions = (deps = {}) => {
     getModifierTags: getModifierTags(innerDeps),
     isRelatedItem: isRelatedItem(innerDeps),
     getParentItem: getParentItem(innerDeps),
-    isParentIncluded: isParentIncluded(innerDeps),
+    isRepairOnly: isRepairOnly(innerDeps),
     hasCreateSubscription: hasCreateSubscription(innerDeps),
     getItemModifiers: getItemModifiers(innerDeps),
     getItemsBalance: getItemsBalance(innerDeps),
@@ -133,8 +136,6 @@ const itemActions = (deps = {}) => {
     validateModifiersByQuantity: validateModifiersByQuantity(innerDeps),
     getModifiersBySingleValueId: getModifiersBySingleValueId(innerDeps),
     getLastLocation: getLastLocation(innerDeps),
-    hasAddModifiers: hasAddModifiers(innerDeps),
-    getAddModifiers: getAddModifiers(innerDeps),
     getRelatedItems: getRelatedItems(innerDeps),
     getRelatedModifiers: getRelatedModifiers(innerDeps),
     unpickItem: unpickItem(innerDeps),
@@ -161,6 +162,11 @@ const itemActions = (deps = {}) => {
     isSerialRequired: isSerialRequired(innerDeps),
     isSerialLengthValid: isSerialLengthValid(innerDeps),
     getSerialStatus: getSerialStatus(innerDeps),
+    removeDepartmentModifiers: removeDepartmentModifiers(innerDeps),
+    isRemoveParentItem: isRemoveParentItem(innerDeps),
+    hasRelatedItems: hasRelatedItems(innerDeps),
+    getAddModifiers: getAddModifiers(innerDeps),
+    hasAddModifiers: hasAddModifiers(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/isRemoveParentItem.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isRemoveParentItem(item) {
+    return !!(item && item.properties && item.properties.removeParentItem);
+  };

package/lib/item/isRepairOnly.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isRepairOnly(item) {
+    return !!(!!item && !!item.properties && !!item.properties.repairOnly);
+  };

package/lib/item/removeDepartmentModifiers.js

@@ -0,0 +1,19 @@
+module.exports = ({ actions, modifierActions }) =>
+  function removeDepartmentModifiers({ item, order }) {
+    if (!item) return undefined;
+    if (!Array.isArray(item.modifiers)) return item;
+    const deparmentModifiers = item.modifiers.filter(mod =>
+      modifierActions.isDepartment(mod)
+    );
+
+    const newItem = deparmentModifiers.reduce(
+      (nextItem, modifier) =>
+        actions.removeModifier({
+          item: nextItem,
+          modifier,
+          order,
+        }),
+      item
+    );
+    return newItem;
+  };

package/lib/modifier/getInheritedModifiers.js

@@ -1,30 +1,14 @@
-module.exports = ({ actions }) => {
-  const isRelated = modifier => actions.isGroupOfItems(modifier);
+module.exports = ({ actions }) =>
+  function getInheritedModifiers({ parentItem }) {
+    if (!parentItem || !Array.isArray(parentItem.modifiers)) return [];
 
-  return function getInheritedModifiers({ parentItem, childItem }) {
-    if (!parentItem || !childItem) return [];
+    const modifiersToAdd = [];
 
-    const { addModifiers: parentModifiers } = parentItem;
-    const { addModifiers: childModifiers = [], _id } = childItem;
-    const modifiers = [...childModifiers];
+    parentItem.modifiers.forEach(parentMod => {
+      if (!actions.isDepartment(parentMod) && !actions.isGroup(parentMod)) {
+        modifiersToAdd.push(parentMod);
+      }
+    });
 
-    const relatedItemModifier = parentModifiers.find(each => isRelated(each));
-    if (!relatedItemModifier) return modifiers;
-
-    const { properties = {} } = relatedItemModifier;
-    const items = (properties.group && properties.group.items) || [];
-
-    const relatedItem = items.find(each => each._id === _id);
-    if (!relatedItem) return [];
-
-    if (properties.inheritModifiers && parentModifiers.length) {
-      const inheritedModifiers = parentModifiers
-        .filter(each => !isRelated(each))
-        .map(each => actions.duplicate(each));
-
-      if (inheritedModifiers.length) modifiers.push(...inheritedModifiers);
-    }
-
-    return modifiers;
+    return modifiersToAdd;
   };
-};

package/lib/modifier/index.js

@@ -181,6 +181,7 @@ const getPromoCustomerIds = require('./getPromoCustomerIds');
 const getCountPerCustomer = require('./getCountPerCustomer');
 const getAmountMultiplier = require('./getAmountMultiplier');
 const isAmountMultiplier = require('./isAmountMultiplier');
+const isRemoveParentItem = require('./isRemoveParentItem');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -374,6 +375,7 @@ const modifierActions = (deps = {}) => {
     getCountPerCustomer: getCountPerCustomer(innerDeps),
     getAmountMultiplier: getAmountMultiplier(innerDeps),
     isAmountMultiplier: isAmountMultiplier(innerDeps),
+    isRemoveParentItem: isRemoveParentItem(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isRemoveParentItem.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function isRemoveParentItem(modifier) {
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.group &&
+      modifier.properties.group.removeParentItem
+    );
+  };

package/lib/order/addItem.js

@@ -147,7 +147,11 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       }
     }
 
-    if (autoBarcode && !orderItem.serial) {
+    if (
+      autoBarcode &&
+      !orderItem.serial &&
+      !itemActions.isRelatedItem(orderItem)
+    ) {
       orderItem.serial = autoBarcode;
     }
 
@@ -164,17 +168,30 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
         item: orderItem,
       });
       if (itemActions.isRelatedItem(orderItem)) {
-        const parent = itemActions.getParentItem(order.items, orderItem);
-        // get inherited modifiers
-        const inheritedModifiers = modifierActions.getInheritedModifiers({
-          parent,
-          child: item,
-        });
-        if (!_.isEmpty(inheritedModifiers))
-          modifiersToAdd.push(...inheritedModifiers);
-        // Remove parent if it is only a repair Item
-        if (!itemActions.isParentIncluded(orderItem) && !!parent) {
-          order = actions.resetItem({ order, item: parent });
+        let parent = itemActions.getParentItem(order.parentItems, orderItem);
+
+        if (!parent) {
+          parent = itemActions.getParentItem(order.items, orderItem);
+          order = actions.copyItemToParents({ order, item: parent });
+        }
+
+        modifiersToAdd.push(
+          ...modifierActions.getInheritedModifiers({ parentItem: parent })
+        );
+
+        orderItem.serial = parent.serial;
+
+        if (parent && itemActions.isRepairOnly(orderItem)) {
+          if (itemActions.isRemoveParentItem(item)) {
+            order = actions.removeItem({
+              order,
+              item: parent,
+              skipParentsCheck: true,
+              keepRelatedItems: true,
+            });
+          } else {
+            order = actions.resetItem({ order, item: parent });
+          }
         }
       }
     }
@@ -248,36 +265,10 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       nextOrder.items.splice(idxToRemove, 1);
     }
 
-    if (
-      itemActions.isRelatedItem(item) &&
-      itemActions.hasAddModifiers(item) &&
-      itemActions.isParentIncluded(item)
-    ) {
-      const parentItem = itemActions.getParentItem(nextOrder.items, item);
-      const parentIndex = actions.getItemIndex({
-        order: nextOrder,
-        item: parentItem,
-      });
-      const relatedModifiersToAdd = itemActions
-        .getAddModifiers(item)
-        .filter(
-          mod =>
-            !parentItem.modifiers.some(
-              itemMod => itemMod.modifierId === mod._id
-            )
-        );
-
-      nextOrder = relatedModifiersToAdd.reduce(
-        (acc, modifier) =>
-          actions.addItemModifier({
-            itemIndex: parentIndex,
-            order: acc,
-            modifier,
-            originalItem: parentItem,
-          }),
-        nextOrder
-      );
-    }
+    nextOrder = actions.addModifiersToParentItem({
+      order: nextOrder,
+      relatedItem: orderItem,
+    });
 
     return {
       updatedOrder: nextOrder,

package/lib/order/addItemModifier.js

@@ -192,7 +192,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
               relatedItem: true,
               parentId: item._id,
               parentItemId: item.itemId,
-              includeParent: true,
+              repairOnly: false,
             },
           },
           order: acc,

package/lib/order/addModifiersToParentItem.js

@@ -0,0 +1,41 @@
+module.exports = ({ actions, itemActions }) =>
+  function addModifiersToParentItem({ order, relatedItem }) {
+    if (
+      !order ||
+      !itemActions.isRelatedItem(relatedItem) ||
+      !itemActions.hasAddModifiers(relatedItem) ||
+      itemActions.isRepairOnly(relatedItem)
+    ) {
+      return order;
+    }
+
+    let nextOrder = { ...order };
+
+    const parentItem = itemActions.getParentItem(nextOrder.items, relatedItem);
+    const parentIndex = actions.getItemIndex({
+      order: nextOrder,
+      item: parentItem,
+    });
+
+    if (parentIndex < 0) return nextOrder;
+
+    const relatedModifiersToAdd = itemActions
+      .getAddModifiers(relatedItem)
+      .filter(
+        mod =>
+          !parentItem.modifiers.some(itemMod => itemMod.modifierId === mod._id)
+      );
+
+    nextOrder = relatedModifiersToAdd.reduce(
+      (acc, modifier) =>
+        actions.addItemModifier({
+          itemIndex: parentIndex,
+          order: acc,
+          modifier,
+          originalItem: parentItem,
+        }),
+      nextOrder
+    );
+
+    return nextOrder;
+  };

package/lib/order/copyItemToParents.js

@@ -0,0 +1,19 @@
+module.exports = ({ itemActions }) =>
+  function copyItemToParents({ item, order }) {
+    if (!order || !item || itemActions.isRelatedItem(item)) return order;
+    if (!item._id) return order;
+
+    const alreadyExists =
+      order.parentItems &&
+      order.parentItems.some(parentItem => parentItem._id === item._id);
+
+    if (alreadyExists) return order;
+
+    const parentItems = Array.isArray(order.parentItems)
+      ? [...order.parentItems]
+      : [];
+
+    parentItems.push(item);
+
+    return { ...order, parentItems };
+  };

package/lib/order/getItemsWithParents.js

@@ -0,0 +1,31 @@
+module.exports = ({ itemActions }) =>
+  function getItemsWithParents({ items, parentItems }) {
+    if (!Array.isArray(items)) return [];
+
+    if (!Array.isArray(parentItems) || parentItems.length === 0) return items;
+
+    const result = [];
+
+    items.forEach(item => {
+      if (!itemActions.isRelatedItem(item)) {
+        result.push(item);
+        return;
+      }
+
+      const parentId =
+        item && item.properties ? item.properties.parentId : undefined;
+      const parentInOrder = items.find(p => p && p._id === parentId);
+      const parentInParentItems = parentItems.find(
+        p => p && p._id === parentId
+      );
+      const parentInResult = result.find(i => i && i._id === parentId);
+
+      if (!parentInOrder && parentInParentItems && !parentInResult) {
+        result.push(parentInParentItems);
+      }
+
+      result.push(item);
+    });
+
+    return result;
+  };

package/lib/order/index.js

@@ -92,6 +92,9 @@ const mapSubOrders = require('./mapSubOrders');
 const isFullyPaid = require('./isFullyPaid');
 const getUpdatedStatus = require('./getUpdatedStatus');
 const setPieces = require('./setPieces');
+const copyItemToParents = require('./copyItemToParents');
+const getItemsWithParents = require('./getItemsWithParents');
+const addModifiersToParentItem = require('./addModifiersToParentItem');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -195,6 +198,9 @@ const orderActions = (deps = {}) => {
     isFullyPaid: isFullyPaid(innerDeps),
     getUpdatedStatus: getUpdatedStatus(innerDeps),
     setPieces: setPieces(innerDeps),
+    copyItemToParents: copyItemToParents(innerDeps),
+    getItemsWithParents: getItemsWithParents(innerDeps),
+    addModifiersToParentItem: addModifiersToParentItem(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/removeItem.js

@@ -1,5 +1,5 @@
 module.exports = ({ actions, itemActions }) => {
-  const remove = ({ order, item, checkQuantity }) => {
+  const remove = ({ order, item, checkQuantity, keepRelatedItems }) => {
     const orderItemIdx = actions.getItemIndex({ order, item });
     if (orderItemIdx < 0) return order;
 
@@ -19,53 +19,12 @@ module.exports = ({ actions, itemActions }) => {
 
     items.splice(orderItemIdx, 1);
 
-    let resultedOrder = {
+    const resultedOrder = {
       ...order,
       items,
     };
 
-    if (itemActions.isRelatedItem(item) && itemActions.hasAddModifiers(item)) {
-      const parentItem = itemActions.getParentItem(order.items, item);
-
-      if (parentItem) {
-        resultedOrder = item.properties.addModifiers.reduce(
-          (prevOrder, addModifier) => {
-            if (
-              !itemActions.hasModifier({
-                item: parentItem,
-                modifier: addModifier,
-                relatedItems: actions.getRelatedItems({
-                  order: prevOrder,
-                  item: parentItem,
-                }),
-              })
-            ) {
-              const updatedItem = itemActions.removeModifier({
-                item: parentItem,
-                modifier: addModifier,
-                originalItem: parentItem,
-              });
-              const itemIndexToUpdate = actions.getItemIndex({
-                order: prevOrder,
-                item: parentItem,
-              });
-              if (itemIndexToUpdate >= 0) {
-                const itemsToUpdate = [...prevOrder.items];
-
-                itemsToUpdate.splice(itemIndexToUpdate, 1, updatedItem);
-
-                return {
-                  ...resultedOrder,
-                  items: itemsToUpdate,
-                };
-              }
-            }
-            return resultedOrder;
-          },
-          resultedOrder
-        );
-      }
-    }
+    if (keepRelatedItems) return resultedOrder;
 
     const relatedItems = actions.getRelatedItems({ order, item });
     if (relatedItems.length > 0) {
@@ -83,10 +42,22 @@ module.exports = ({ actions, itemActions }) => {
     return resultedOrder;
   };
 
-  return function removeItem({ order, item, checkQuantity }) {
+  return function removeItem({
+    order,
+    item,
+    checkQuantity,
+    skipParentsCheck,
+    keepRelatedItems,
+  }) {
     if (!order || !Array.isArray(order.items) || !item) return order;
 
-    const nextOrder = remove({ order, item, checkQuantity });
+    const nextOrder = remove({ order, item, checkQuantity, keepRelatedItems });
+
+    if (!skipParentsCheck && Array.isArray(nextOrder.parentItems)) {
+      nextOrder.parentItems = nextOrder.parentItems.filter(parentItem =>
+        itemActions.hasRelatedItems({ parentItem, items: nextOrder.items })
+      );
+    }
 
     return nextOrder;
   };

package/lib/order/splitByDepartments.js

@@ -49,8 +49,13 @@ module.exports = ({
       return Number(aIsRelated) - Number(bIsRelated);
     });
 
+    const { parentItems } = parentOrderParam;
+
     const itemsByDepartments = _.groupBy(sortedItems, item =>
-      itemActions.getSplitDepartment({ items: sortedItems, item })
+      itemActions.getSplitDepartment({
+        parentItems,
+        item,
+      })
     );
     const itemGroups = Object.values(itemsByDepartments);
     let splitOrders = [];
@@ -64,7 +69,7 @@ module.exports = ({
       // Assuming there is one department in the item
       const department = itemActions.getDepartmentModifiers(items[0])[0];
       const departmentName = itemActions.getSplitDepartment({
-        items: sortedItems,
+        parentItems,
         item: items[0],
       });
       const maxItems = modifierActions.getDepartmentMaxItems(department);
@@ -129,7 +134,7 @@ module.exports = ({
                   maxItems &&
                 departmentName ===
                   itemActions.getSplitDepartment({
-                    items: sortedItems,
+                    parentItems,
                     item: items[0],
                   })
             );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.131",
+  "version": "1.0.133",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -52,5 +52,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "b4f267cbf11b2857a4fc01053cc315036e63392f"
+  "gitHead": "1cec04f4a6fc32238922712068994984b62ab92d"
 }

package/__TEST__/manualTest.test.js

@@ -1,89 +0,0 @@
-const usePricing = require('../index');
-const mockStores = require('./mocks/stores');
-
-const session = {
-  store: mockStores[0],
-};
-
-const pricingService = usePricing(session);
-
-describe('Manual actions', () => {
-  test('Should add related item and its related addModifiers to the parent item, then removing that relateditem should also remove the mod from the parent item', () => {
-    const rawRelatedItem1 = {
-      name: 'the related item',
-      _id: '67e2cadd8dcf08ebcc5ef888',
-    };
-
-    const rawRelatedItem2 = {
-      name: 'the 2nd related item',
-      _id: '67e2cadd8dcf08ebcc5ef88a',
-    };
-
-    const groupMod = {
-      _id: '67e2cadd8dcf08ebcc5ef889',
-      name: 'General Repair Department',
-      attributes: ['group'],
-      modifierId: 'mod1',
-      properties: {
-        group: {
-          items: [],
-        },
-      },
-    };
-
-    const parentItem = {
-      name: 'the parent item',
-      modifiers: [groupMod],
-      _id: '67e2cadd8dcf08ebcc5ef887',
-      __typename: 'OrderItem',
-
-      itemId: 'abcd123',
-    };
-
-    const relatedItem1 = {
-      ...rawRelatedItem1,
-      properties: {
-        relatedItem: true,
-        parentId: parentItem._id,
-        parentItemId: parentItem.itemId,
-        includeParent: true,
-        addModifiers: [groupMod],
-        groupPath: ',67e2cadd8dcf08ebcc5ef889',
-      },
-      __typename: 'OrderItem',
-    };
-
-    const relatedItem2 = {
-      ...rawRelatedItem2,
-      properties: {
-        relatedItem: true,
-        parentId: parentItem._id,
-        parentItemId: parentItem.itemId,
-        includeParent: true,
-        addModifiers: [groupMod],
-        groupPath: ',67e2cadd8dcf08ebcc5ef889',
-      },
-      __typename: 'OrderItem',
-    };
-    const order = {
-      items: [parentItem, relatedItem1, relatedItem2],
-    };
-
-    const result = pricingService.order.removeItem({
-      order,
-      item: relatedItem2,
-    });
-
-    expect(result.items.length).toBe(2);
-    expect(result.items[0].modifiers.length).toBe(1);
-    expect(result.items[0].modifiers[0].modifierId).toBe('mod1');
-
-    // const result2 = pricingService.order.removeItem({
-    //   order: result,
-    //   item: relatedItem1,
-    // });
-
-    // expect(result2.items.length).toBe(1);
-    // expect(result2.items[0].modifiers.length).toBe(0);
-  });
-});

package/lib/item/isParentIncluded.js

@@ -1,4 +0,0 @@
-module.exports = () =>
-  function isParentIncluded(item) {
-    return item && item.properties && item.properties.includeParent;
-  };