@darkpos/pricing 1.0.67 → 1.0.69

package/__TEST__/item/getModifierTags.test.js

@@ -356,11 +356,12 @@ describe('getModifierTags Function', () => {
 
     const result = pricingServiceGroupModifiers.item.getModifierTags({ item });
 
-    expect(result).toHaveLength(2);
-    expect(result[0].label.replace(/\s/g, '')).toEqual(
+    expect(result).toHaveLength(3);
+    expect(result[0].label.replace(/\s/g, '')).toEqual('1White');
+    expect(result[1].label.replace(/\s/g, '')).toEqual(
       '1CRC5.10discount(-CRC5.10)'
     );
-    expect(result[1].label.replace(/\s/g, '')).toEqual(
+    expect(result[2].label.replace(/\s/g, '')).toEqual(
       '1CRC37.50discount(-CRC37.50)'
     );
   });

package/__TEST__/item.test.js

@@ -1,6 +1,11 @@
 const usePricing = require('../index');
+const mockStores = require('./mocks/stores');
 
-const pricingService = usePricing();
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
 
 describe('Item actions', () => {
   test('Get calculated Item: included: false && direct: false', () => {
@@ -856,4 +861,448 @@ describe('Item actions', () => {
       _actual: 135,
     });
   });
+
+  test('Remove Item', () => {
+    const item1 = {
+      _id: '1',
+    };
+    const item2 = {
+      _id: '2',
+    };
+
+    const order = {
+      items: [item1, item2],
+    };
+    const result = pricingService.order.removeItem({ order, item: item2 });
+
+    expect(result.items).toMatchObject([{ _id: '1' }]);
+  });
+
+  test('Remove related Item', () => {
+    const item1 = {
+      _id: '1',
+      itemId: 'a',
+    };
+    const item2 = {
+      _id: '2',
+    };
+    const item3 = {
+      _id: '3',
+      properties: {
+        relatedItem: true,
+        parentId: item1._id,
+        parentItemId: item1.itemId,
+      },
+    };
+
+    const order = {
+      items: [item1, item2, item3],
+    };
+    const result = pricingService.order.removeItem({ order, item: item3 });
+
+    expect(result.items).toMatchObject([
+      {
+        _id: '1',
+      },
+      {
+        _id: '2',
+      },
+    ]);
+  });
+
+  test('Remove parent Item having 1 related item', () => {
+    const item1 = {
+      _id: '1',
+      itemId: 'a',
+    };
+    const item2 = {
+      _id: '2',
+    };
+    const item3 = {
+      _id: '3',
+      properties: {
+        relatedItem: true,
+        parentId: item1._id,
+        parentItemId: item1.itemId,
+      },
+    };
+
+    const order = {
+      items: [item1, item2, item3],
+    };
+    const result = pricingService.order.removeItem({ order, item: item1 });
+
+    expect(result.items).toMatchObject([
+      {
+        _id: '2',
+      },
+    ]);
+  });
+
+  test('Remove parent Item, having more than 1 related item', () => {
+    const item1 = {
+      _id: '1',
+      itemId: 'a',
+    };
+    const item2 = {
+      _id: '2',
+    };
+    const item3 = {
+      _id: '3',
+      properties: {
+        relatedItem: true,
+        parentId: item1._id,
+        parentItemId: item1.itemId,
+      },
+    };
+    const item4 = {
+      _id: '4',
+      properties: {
+        relatedItem: true,
+        parentId: item1._id,
+        parentItemId: item1.itemId,
+      },
+    };
+
+    const order = {
+      items: [item1, item2, item3, item4],
+    };
+    const result = pricingService.order.removeItem({ order, item: item1 });
+
+    expect(result.items).toMatchObject([
+      {
+        _id: '2',
+      },
+    ]);
+  });
+
+  test('Remove related Item, having nested related items', () => {
+    const item1 = {
+      _id: '1',
+      itemId: 'a',
+    };
+    const item2 = {
+      _id: '2',
+    };
+    const item3 = {
+      _id: '3',
+      properties: {
+        relatedItem: true,
+        parentId: item1._id,
+        parentItemId: item1.itemId,
+      },
+    };
+    const item4 = {
+      _id: '4',
+      itemId: 'd',
+      properties: {
+        relatedItem: true,
+        parentId: item1._id,
+        parentItemId: item1.itemId,
+      },
+    };
+
+    const nestedItem5 = {
+      _id: '5',
+      properties: {
+        relatedItem: true,
+        parentId: item4._id,
+        parentItemId: item4.itemId,
+      },
+    };
+
+    const order = {
+      items: [item1, item2, item3, item4, nestedItem5],
+    };
+    const result = pricingService.order.removeItem({
+      order,
+      item: nestedItem5,
+    });
+
+    expect(result.items).toMatchObject([item1, item2, item3, item4]);
+  });
+
+  test('Remove related Item, having nested related items 2', () => {
+    const item1 = {
+      _id: '1',
+      itemId: 'a',
+    };
+    const item2 = {
+      _id: '2',
+    };
+    const item3 = {
+      _id: '3',
+      properties: {
+        relatedItem: true,
+        parentId: item1._id,
+        parentItemId: item1.itemId,
+      },
+    };
+    const item4 = {
+      _id: '4',
+      itemId: 'd',
+      properties: {
+        relatedItem: true,
+        parentId: item1._id,
+        parentItemId: item1.itemId,
+      },
+    };
+
+    const nestedItem5 = {
+      _id: '5',
+      properties: {
+        relatedItem: true,
+        parentId: item4._id,
+        parentItemId: item4.itemId,
+      },
+    };
+
+    const nestedItem6 = {
+      _id: '6',
+      properties: {
+        relatedItem: true,
+        parentId: item4._id,
+        parentItemId: item4.itemId,
+      },
+    };
+
+    const order = {
+      items: [item1, item2, item3, item4, nestedItem5, nestedItem6],
+    };
+    const result = pricingService.order.removeItem({
+      order,
+      item: nestedItem5,
+    });
+
+    expect(result.items).toMatchObject([
+      item1,
+      item2,
+      item3,
+      item4,
+      nestedItem6,
+    ]);
+  });
+
+  test('Remove parent related Item, having nested related items', () => {
+    const item1 = {
+      _id: '1',
+      itemId: 'a',
+    };
+    const item2 = {
+      _id: '2',
+    };
+    const item3 = {
+      _id: '3',
+      properties: {
+        relatedItem: true,
+        parentId: item1._id,
+        parentItemId: item1.itemId,
+      },
+    };
+    const item4 = {
+      _id: '4',
+      itemId: 'd',
+      properties: {
+        relatedItem: true,
+        parentId: item1._id,
+        parentItemId: item1.itemId,
+      },
+    };
+
+    const nestedItem5 = {
+      _id: '5',
+      properties: {
+        relatedItem: true,
+        parentId: item4._id,
+        parentItemId: item4.itemId,
+      },
+    };
+
+    const nestedItem6 = {
+      _id: '6',
+      properties: {
+        relatedItem: true,
+        parentId: item4._id,
+        parentItemId: item4.itemId,
+      },
+    };
+
+    const order = {
+      items: [item1, item2, item3, item4, nestedItem5, nestedItem6],
+    };
+    const result = pricingService.order.removeItem({ order, item: item1 });
+
+    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: [rawRelatedItem1, rawRelatedItem2],
+        },
+      },
+    };
+
+    const parentItem = {
+      name: 'the parent item',
+      modifiers: [groupMod],
+      _id: '67e2cadd8dcf08ebcc5ef887',
+      __typename: 'OrderItem',
+      properties: {
+        basePrice: 100,
+      },
+    };
+
+    const relatedItem1 = {
+      ...rawRelatedItem1,
+      properties: {
+        relatedItem: true,
+        parentId: parentItem._id,
+        includeParent: true,
+        addModifiers: [groupMod],
+        relatedItemId: rawRelatedItem1._id,
+      },
+      __typename: 'OrderItem',
+    };
+
+    const relatedItem2 = {
+      ...rawRelatedItem2,
+      properties: {
+        relatedItem: true,
+        parentId: parentItem._id,
+        includeParent: true,
+        addModifiers: [groupMod],
+        relatedItemId: rawRelatedItem2._id,
+      },
+      __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',
+      _id: '67e2cadd8dcf08ebcc5ef888',
+    };
+
+    const rawRelatedItem2 = {
+      name: 'the 2nd related item',
+      _id: '67e2cadd8dcf08ebcc5ef88a',
+    };
+
+    const rawRelatedMod1 = {
+      name: 'related modifier',
+      _id: '123',
+      modifierId: 'abc',
+      addModifiers: [
+        {
+          _id: '67e2cadd8dcf08ebcc5ef889',
+          name: 'General Repair Department',
+          attributes: ['group'],
+          modifierId: 'mod1',
+          properties: {
+            group: {
+              items: [rawRelatedItem1, rawRelatedItem2],
+            },
+          },
+        },
+      ],
+    };
+
+    const groupMod = {
+      _id: '67e2cadd8dcf08ebcc5ef889',
+      name: 'General Repair Department',
+      attributes: ['group'],
+      modifierId: 'mod1',
+      properties: {
+        group: {
+          items: [rawRelatedItem1, rawRelatedItem2],
+          modifiers: [rawRelatedMod1],
+        },
+      },
+    };
+
+    const parentItem = {
+      name: 'the parent item',
+      modifiers: [groupMod, rawRelatedMod1],
+      _id: '67e2cadd8dcf08ebcc5ef887',
+      __typename: 'OrderItem',
+      properties: {
+        basePrice: 100,
+      },
+    };
+
+    const relatedItem1 = {
+      ...rawRelatedItem1,
+      properties: {
+        relatedItem: true,
+        parentId: parentItem._id,
+        includeParent: true,
+        addModifiers: [groupMod],
+        relatedItemId: rawRelatedItem1._id,
+      },
+      __typename: 'OrderItem',
+    };
+
+    const relatedItem2 = {
+      ...rawRelatedItem2,
+      properties: {
+        relatedItem: true,
+        parentId: parentItem._id,
+        includeParent: true,
+        addModifiers: [groupMod],
+        relatedItemId: rawRelatedItem2._id,
+      },
+      __typename: 'OrderItem',
+    };
+    const order = {
+      items: [parentItem, relatedItem1, relatedItem2],
+    };
+
+    const newItem = pricingService.item.removeModifiers({
+      item: parentItem,
+      modifiers: [rawRelatedMod1],
+      originalItem: parentItem,
+      customer: undefined,
+      order,
+    });
+
+    expect(newItem.modifiers.length).toBe(1);
+    expect(newItem.modifiers[0].name).toBe('General Repair Department');
+  });
 });

package/__TEST__/modifier/hasModifier.test.js

@@ -1,6 +1,11 @@
 const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
 
-const pricingService = usePricing();
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
 
 describe('hasModifier Function', () => {
   test('hasModifier should return false for an item that only has white(group modifier)', () => {
@@ -1623,4 +1628,70 @@ describe('hasModifier Function', () => {
 
     expect(hasModifier).toBe(false);
   });
+
+  test('hasModifier, using only 1 related items', () => {
+    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] };
+
+    const order = {
+      items: [item],
+      modifiers: [],
+    };
+
+    // const modifier = groupMod;
+    // const relatedItems = [];
+
+    // const result = pricingService.item.hasModifier({
+    //   item,
+    //   modifier,
+    //   relatedItems,
+    // });
+
+    const { updatedOrder } = pricingService.order.addItem({
+      order,
+      item: {
+        ...relatedModItem,
+        properties: {
+          relatedItem: true,
+          parentItemId: item.itemId,
+          parentId: item._id,
+          includeParent: true,
+          relatedItemId: relatedModItem._id,
+        },
+      },
+    });
+
+    expect(updatedOrder.items.length).toBe(2);
+
+    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);
+  });
 });

package/__TEST__/order/addItem.test.js

@@ -199,4 +199,107 @@ describe('addItem function', () => {
     ); // Check second modifier
     expect(updatedOrder.items[0].modifiers).toHaveLength(2); // Added item should have modifiers
   });
+
+  test('Add Related Item', () => {
+    const { addItem } = pricingService.order;
+
+    const parentItem = {
+      _id: '1',
+      quantity: 1,
+      price: 100,
+      modifiers: [],
+      name: 'the parent item',
+    };
+
+    const { updatedOrder } = addItem({
+      order: { items: [] },
+      item: parentItem,
+    });
+
+    expect(updatedOrder.items).toHaveLength(1);
+    expect(updatedOrder.items[0]).toMatchObject({
+      name: 'the parent item',
+    });
+
+    const relatedItem = {
+      _id: 'related1',
+      name: 'the related item',
+      quantity: 1,
+      price: 100,
+      modifiers: [],
+      properties: {
+        relatedItem: true,
+        parentItemId: updatedOrder.items[0].itemId,
+        parentId: updatedOrder.items[0]._id,
+        includeParent: true,
+        addModifiers: [
+          {
+            _id: 'mod1',
+            name: 'General Repair Department',
+            attributes: ['group'],
+          },
+        ],
+      },
+    };
+
+    const { updatedOrder: updatedOrder2 } = addItem({
+      order: updatedOrder,
+      item: relatedItem,
+    });
+
+    expect(updatedOrder2.items).toHaveLength(2);
+    expect(updatedOrder2.items[0]).toMatchObject({
+      name: 'the related item',
+    });
+    expect(updatedOrder2.items[1]).toMatchObject({
+      name: 'the parent item',
+      modifiers: [
+        {
+          name: 'General Repair Department',
+        },
+      ],
+    });
+
+    const relatedItem2 = {
+      _id: 'related1',
+      name: 'the 2nd related item',
+      quantity: 1,
+      price: 100,
+      modifiers: [],
+      properties: {
+        relatedItem: true,
+        parentItemId: updatedOrder.items[0].itemId,
+        parentId: updatedOrder.items[0]._id,
+        includeParent: true,
+        addModifiers: [
+          {
+            _id: 'mod1',
+            name: 'General Repair Department',
+            attributes: ['group'],
+          },
+        ],
+      },
+    };
+
+    const { updatedOrder: updatedOrder3 } = addItem({
+      order: updatedOrder2,
+      item: relatedItem2,
+    });
+
+    expect(updatedOrder3.items).toHaveLength(3);
+    expect(updatedOrder3.items[0]).toMatchObject({
+      name: 'the 2nd related item',
+    });
+    expect(updatedOrder3.items[1]).toMatchObject({
+      name: 'the related item',
+    });
+    expect(updatedOrder3.items[2]).toMatchObject({
+      name: 'the parent item',
+      modifiers: [
+        {
+          name: 'General Repair Department',
+        },
+      ],
+    });
+  });
 });

package/lib/item/getAddModifiers.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function getAddModifiers(item) {
+    if (
+      !item ||
+      !item.properties ||
+      !Array.isArray(item.properties.addModifiers)
+    )
+      return [];
+
+    return item.properties.addModifiers;
+  };

package/lib/item/getModifierTags.js

@@ -1,22 +1,12 @@
 module.exports = ({ modifierActions, settings }) =>
-  function getModifierTags({
-    item,
-    includePaymentModifiers,
-    skipGrouping = false,
-  }) {
+  function getModifierTags({ item, skipGrouping = false }) {
     const groupModifiers =
       settings && settings.order && settings.order.groupModifiers;
 
     if (!item || !Array.isArray(item.modifiers)) return [];
 
     let modifierTags = item.modifiers
-      .filter(
-        each =>
-          (modifierActions.isValid(each) ||
-            (modifierActions.isPaymentModifier(each) &&
-              includePaymentModifiers)) &&
-          !modifierActions.isGroup(each)
-      )
+      .filter(each => modifierActions.isValid(each))
       .map(modifier => {
         const { name, _id } = modifier;
 

package/lib/item/getRelatedItems.js

@@ -0,0 +1,12 @@
+module.exports = () =>
+  function getRelatedItems({ items, item, compareId = true }) {
+    if (!items || !item) return [];
+
+    return items
+      .filter(each => each.properties && each.properties.relatedItem)
+      .filter(
+        each =>
+          each.properties.parentItemId === item.itemId &&
+          (compareId ? each.properties.parentId === item._id : true)
+      );
+  };

package/lib/item/hasAddModifiers.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function hasAddModifiers(item) {
+    return (
+      !!item &&
+      !!item.properties &&
+      !!item.properties.addModifiers &&
+      !!item.properties.addModifiers.length
+    );
+  };

package/lib/item/hasModifier.js

@@ -1,27 +1,36 @@
 module.exports = ({ modifierActions }) =>
-  function hasModifier({ item, modifier }) {
+  function hasModifier({ item, modifier, relatedItems, originalModifier }) {
     if (!item || !modifier || !item.modifiers) return false;
 
+    const originalMod = originalModifier || modifier;
+
     if (modifierActions.isGroupOfModifiers(modifier)) {
       const relatedModifiers = modifier.properties.group.modifiers;
       return [
         modifierActions.removeGroupData({ modifier }),
         ...relatedModifiers,
       ].some(relatedModifier =>
-        hasModifier({ item, modifier: relatedModifier })
+        hasModifier({
+          item,
+          modifier: relatedModifier,
+          relatedItems,
+          originalModifier: originalMod,
+        })
       );
     }
 
-    const itemModifier = item.modifiers
-      .filter(itemMod => !modifierActions.isGroupOfModifiers(itemMod))
-      .find(
-        each =>
-          (each.modifierId &&
-            (each.modifierId === modifier.modifierId ||
-              each.modifierId === modifier._id)) ||
-          (typeof each.modifier === 'object' &&
-            each.modifier._id === modifier.modifierId)
+    const matchByModifier = item.modifiers.some(
+      each => !modifierActions.isGroup(each) && each.modifierId === modifier._id
+    );
+
+    const matchByRelatedItems =
+      !!relatedItems &&
+      modifierActions.isGroupOfItems(originalMod) &&
+      relatedItems.some(relatedItem =>
+        originalMod.properties.group.items.some(
+          modItem => modItem._id === relatedItem.properties.relatedItemId
+        )
       );
 
-    return !!itemModifier;
+    return matchByModifier || matchByRelatedItems;
   };

package/lib/item/hasModifiers.js

@@ -1,8 +1,8 @@
 module.exports = ({ actions }) =>
-  function hasModifiers({ item, modifiers }) {
+  function hasModifiers({ item, modifiers, relatedItems }) {
     if (!item || !modifiers || !item.modifiers) return false;
 
     return modifiers.some(each =>
-      actions.hasModifier({ item, modifier: each })
+      actions.hasModifier({ item, modifier: each, relatedItems })
     );
   };

package/lib/item/index.js

@@ -31,7 +31,6 @@ const getItemModifiers = require('./getItemModifiers');
 const getItemsBalance = require('./getItemsBalance');
 const isFullyPaid = require('./isFullyPaid');
 const getTotalPrice = require('./getTotalPrice');
-const removePaymentModifiers = require('./removePaymentModifiers');
 const getItems = require('./getItems');
 const getAmounts = require('./getAmounts');
 const hasPaymentMethodType = require('./hasPaymentMethodType');
@@ -48,6 +47,9 @@ const getBasePrice = require('./getBasePrice');
 const removeModifiersByQuantity = require('./removeModifiersByQuantity');
 const getModifiersBySingleValueId = require('./getModifiersBySingleValueId');
 const getLastLocation = require('./getLastLocation');
+const hasAddModifiers = require('./hasAddModifiers');
+const getAddModifiers = require('./getAddModifiers');
+const getRelatedItems = require('./getRelatedItems');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -91,7 +93,6 @@ const itemActions = (deps = {}) => {
     getItemsBalance: getItemsBalance(innerDeps),
     isFullyPaid: isFullyPaid(innerDeps),
     getTotalPrice: getTotalPrice(innerDeps),
-    removePaymentModifiers: removePaymentModifiers(innerDeps),
     getItems: getItems(innerDeps),
     getAmounts: getAmounts(innerDeps),
     hasPaymentMethodType: hasPaymentMethodType(innerDeps),
@@ -109,6 +110,9 @@ const itemActions = (deps = {}) => {
     removeModifiersByQuantity: removeModifiersByQuantity(innerDeps),
     getModifiersBySingleValueId: getModifiersBySingleValueId(innerDeps),
     getLastLocation: getLastLocation(innerDeps),
+    hasAddModifiers: hasAddModifiers(innerDeps),
+    getAddModifiers: getAddModifiers(innerDeps),
+    getRelatedItems: getRelatedItems(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/removeModifier.js

@@ -1,36 +1,59 @@
 module.exports = ({ modifierActions, _, actions }) => {
   const isValid = (itemModifiers, modifier) =>
-    !!modifierActions.findById(itemModifiers, modifier._id);
+    !!modifierActions.findById(itemModifiers, modifier._id) &&
+    (!modifier.required || !modifier._parentId);
 
-  return function removeModifier({ item, modifier, customer, originalItem }) {
+  return function removeModifier({
+    item,
+    modifier,
+    customer,
+    originalItem,
+    order,
+  }) {
     const nextItem = _.cloneDeep(item);
     const itemModifiers = item.modifiers || [];
-    let modifiersToApply = [];
 
     if (!isValid(itemModifiers, modifier)) return item;
 
-    // Check for multiple and add them to menuModifiers
-    if (modifierActions.hasAddModifiers(modifier)) {
-      const relatedModifiers = modifierActions.getRelatedModifiers({
-        modifier,
-      });
-      // Removing only those children who are selected
-      const currentModifiersIds = itemModifiers.map(each => each.modifierId);
-      modifiersToApply = relatedModifiers.filter(each =>
-        currentModifiersIds.includes(each._id)
-      );
-    }
+    const addModifiers = modifierActions.getRelatedModifiers({
+      modifier,
+    });
+
+    const modifiersToApply = [
+      modifier,
+      ...addModifiers.filter(
+        addMod =>
+          !addMod.required &&
+          (!order ||
+            !actions.hasModifier({
+              item: {
+                ...item,
+                modifiers: item.modifiers.filter(
+                  mod => mod._id !== modifier._id
+                ),
+              },
+              modifier: addMod,
+              relatedItems: actions.getRelatedItems({
+                items: order.items,
+                item,
+              }),
+              originalModifier: addMod,
+            }))
+      ),
+    ];
 
-    modifiersToApply.push(modifier);
     // Remove
     const nextModifiers = item.modifiers.filter(
       each =>
         !modifiersToApply.find(
-          mod => each._parentId === mod._id || each._id === mod._id
+          mod =>
+            each._parentId === mod._id ||
+            each._id === mod._id ||
+            each.modifierId === mod._id
         )
     );
 
-    const hasOverride = modifiersToApply.find(each =>
+    const hasOverride = nextModifiers.find(each =>
       modifierActions.isOverride(each)
     );
 

package/lib/item/removeModifiers.js

@@ -1,5 +1,5 @@
 module.exports = ({ actions }) =>
-  function removeModifiers({ item, modifiers, originalItem, customer }) {
+  function removeModifiers({ item, modifiers, originalItem, customer, order }) {
     const newItem = modifiers.reduce(
       (nextItem, modifier) =>
         actions.removeModifier({
@@ -7,6 +7,7 @@ module.exports = ({ actions }) =>
           modifier,
           originalItem,
           customer,
+          order,
         }),
       item
     );

package/lib/modifier/hasAddModifier.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function hasAddModifier({ modifier, addModifier }) {
+    return (
+      actions.hasAddModifiers(modifier) &&
+      !modifier.addModifiers.some(addMod => addMod._id !== addModifier._id)
+    );
+  };

package/lib/modifier/index.js

@@ -141,6 +141,7 @@ const isQuantityMultiplier = require('./isQuantityMultiplier');
 const isCompute = require('./isCompute');
 const isFixedOverride = require('./isFixedOverride');
 const isLocked = require('./isLocked');
+const hasAddModifier = require('./hasAddModifier');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -295,6 +296,7 @@ const modifierActions = (deps = {}) => {
     isCompute: isCompute(innerDeps),
     isFixedOverride: isFixedOverride(innerDeps),
     isLocked: isLocked(innerDeps),
+    hasAddModifier: hasAddModifier(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/addItem.js

@@ -169,7 +169,7 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
           modifiersToAdd.push(...inheritedModifiers);
         // Remove parent if it is only a repair Item
         if (!itemActions.isParentIncluded(orderItem)) {
-          order = actions.removeItem({ order, item: parent, hard: false });
+          order = actions.removeItem({ order, item: parent });
         }
       }
     }
@@ -249,6 +249,33 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       nextOrder.items.splice(idxToRemove, 1);
     }
 
+    if (itemActions.isRelatedItem(item) && itemActions.hasAddModifiers(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
+      );
+    }
+
     return {
       updatedOrder: nextOrder,
       itemIndex: nextItemIndex,

package/lib/order/getModifierRelations.js

@@ -0,0 +1,7 @@
+module.exports = () =>
+  function getModifierRelations({ items, modifier }) {
+    if (!items || !Array.isArray(items) || !modifier)
+      return { items: [], modifier: [] };
+
+    return true;
+  };

package/lib/order/getRelatedItems.js

@@ -1,6 +1,7 @@
 module.exports = () =>
   function getRelatedItems({ order, item, compareId = true }) {
     if (!order || !order.items || !item) return [];
+
     return order.items
       .filter(each => each.properties && each.properties.relatedItem)
       .filter(

package/lib/order/index.js

@@ -32,9 +32,7 @@ const calculate = require('./calculate');
 const isParent = require('./isParent');
 const canSplit = require('./canSplit');
 const removeModifier = require('./removeModifier');
-const removeDiscountModifier = require('./removeDiscountModifier');
 const addModifier = require('./addModifier');
-const addDiscountModifier = require('./addDiscountModifier');
 const calculateDue = require('./calculateDue');
 const toggleModifier = require('./toggleModifier');
 const voidOrder = require('./void');
@@ -89,6 +87,7 @@ const manualSplitByQuantity = require('./manualSplitByQuantity');
 const applyPayment = require('./applyPayment');
 const getBalance = require('./getBalance');
 const getLastLocation = require('./getLastLocation');
+const getModifierRelations = require('./getModifierRelations');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -132,9 +131,7 @@ const orderActions = (deps = {}) => {
     isParent: isParent(innerDeps),
     canSplit: canSplit(innerDeps),
     removeModifier: removeModifier(innerDeps),
-    removeDiscountModifier: removeDiscountModifier(innerDeps),
     addModifier: addModifier(innerDeps),
-    addDiscountModifier: addDiscountModifier(innerDeps),
     calculateDue: calculateDue(innerDeps),
     toggleModifier: toggleModifier(innerDeps),
     voidOrder: voidOrder(innerDeps),
@@ -189,6 +186,7 @@ const orderActions = (deps = {}) => {
     applyPayment: applyPayment(innerDeps),
     getOrdersBalance: getOrdersBalance(innerDeps),
     getLastLocation: getLastLocation(innerDeps),
+    getModifierRelations: getModifierRelations(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/removeItem.js

@@ -1,53 +1,94 @@
-module.exports = ({ actions, _, itemActions }) => {
-  const updateRelatedItems = (items, parentId) =>
-    items.map(each => {
-      const item = { ...each };
-      if (item.properties && item.properties.parentId === parentId)
-        item.properties.includeParent = false;
-      return item;
-    });
-
-  return function removeItem({ order, item, checkQuantity, hard = true }) {
-    if (!item) return order;
-
+module.exports = ({ actions, itemActions }) => {
+  const remove = ({ order, item, checkQuantity }) => {
     const orderItemIdx = actions.getItemIndex({ order, item });
     if (orderItemIdx < 0) return order;
 
-    let { items } = order;
-    const orderItem = items[orderItemIdx];
-    const relatedItems = actions.getRelatedItems({ order, item });
-    const hasRelatedItem = !_.isEmpty(relatedItems);
+    const items = [...order.items];
 
-    if (!hard || hasRelatedItem) {
-      items[orderItemIdx] = { ...orderItem, price: 0, modifiers: [] };
-      if (hasRelatedItem) {
-        items = updateRelatedItems(items, item._id);
-      }
-    }
-    // Decrease the quantity
-    else if (
+    if (
       checkQuantity &&
       items[orderItemIdx] &&
       items[orderItemIdx].quantity > 1
-    )
-      items[orderItemIdx] = { ...orderItem, quantity: orderItem.quantity - 1 };
-    // Remove
-    else items.splice(orderItemIdx, 1);
-
-    // if it is the last relatedItem
-    if (
-      itemActions.isRelatedItem(item) &&
-      !itemActions.isParentIncluded(item)
     ) {
-      const parent = itemActions.getParentItem(items, orderItem);
-      const parentIndex = actions.getItemIndex({ order, item: parent });
-      const siblings = actions.getRelatedItems({ order, item: parent });
-      if (siblings <= 1) items.splice(parentIndex, 1);
+      items[orderItemIdx] = { ...item, quantity: item.quantity - 1 };
+      return {
+        ...order,
+        items,
+      };
     }
 
-    return {
+    items.splice(orderItemIdx, 1);
+
+    let 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,
+                }),
+                originalModifier: addModifier,
+              })
+            ) {
+              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
+        );
+      }
+    }
+
+    const relatedItems = actions.getRelatedItems({ order, item });
+    if (relatedItems.length > 0) {
+      return relatedItems.reduce(
+        (prevOrder, relatedItem) =>
+          remove({
+            order: prevOrder,
+            item: relatedItem,
+            checkQuantity,
+          }),
+        resultedOrder
+      );
+    }
+
+    return resultedOrder;
+  };
+
+  return function removeItem({ order, item, checkQuantity }) {
+    if (!order || !Array.isArray(order.items) || !item) return order;
+
+    const nextOrder = remove({ order, item, checkQuantity });
+
+    return nextOrder;
   };
 };

package/lib/order/removeModifier.js

@@ -16,6 +16,7 @@ module.exports = ({ modifierActions, itemActions }) =>
           itemActions.removeModifier({
             item: each,
             modifier: modifiers[index],
+            order: nextOrder,
           })
         );
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.67",
+  "version": "1.0.69",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -25,6 +25,7 @@
     "test:pickEndDate": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/pickEndDate.test.js",
     "test:modifier": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/modifier.test.js",
     "test:paymentModifiers": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/order-payment-modifier.test.js",
+    "test:addItem": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/addItem.test.js",
     "lint": "eslint --quiet lib/"
   },
   "publishConfig": {
@@ -48,5 +49,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "81b85576c1eb0f3546c48188dc1356146f385176"
+  "gitHead": "eb168a1c07915c479303713d45c4d40ebf692689"
 }

package/lib/item/removePaymentModifiers.js

@@ -1,15 +0,0 @@
-module.exports = ({ actions, modifierActions }) =>
-  function removePaymentModifiers({ items }) {
-    const paymentModifiers = items.modifiers.filter(mod =>
-      modifierActions.isPaymentModifier(mod)
-    );
-
-    return paymentModifiers.map(paymentMod =>
-      items.map(item =>
-        actions.removeModifier({
-          item,
-          modifier: paymentMod,
-        })
-      )
-    );
-  };

package/lib/order/addDiscountModifier.js

@@ -1,9 +0,0 @@
-module.exports = ({ actions }) =>
-  function addDiscountModifier({ order, modifier }) {
-    if (!order || !modifier) return order;
-    const clearedOrder = actions.removeDiscountModifier(order);
-    return actions.addModifier({
-      order: clearedOrder,
-      modifier,
-    });
-  };

package/lib/order/removeDiscountModifier.js

@@ -1,16 +0,0 @@
-module.exports = ({ modifierActions, itemActions }) =>
-  function removeDiscountModifiers(order) {
-    if (!order || !Array.isArray(order.modifiers)) return order;
-    const nextOrder = { ...order };
-    let { modifiers, items } = nextOrder;
-    const discountModifiers = modifiers.filter(modifierActions.isDiscount);
-    modifiers = modifiers.filter(each => !modifierActions.isDiscount(each));
-    if (items)
-      items = items.map(each =>
-        itemActions.removeModifiers({
-          item: each,
-          modifiers: discountModifiers,
-        })
-      );
-    return { ...order, modifiers, items };
-  };