@darkpos/pricing 1.0.130 → 1.0.132

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

@@ -374,4 +374,172 @@ describe('addItemModifier Function', () => {
 
     expect(result.items[0].price).toBe(129);
   });
+
+  test('Calculate item with Override Modifier and unitAsAmountMultiplier=true', () => {
+    const item = {
+      location: {},
+      status: {
+        picked: {
+          value: false,
+          date: '',
+        },
+        paid: {
+          value: false,
+          date: '',
+        },
+        tracker: [],
+      },
+      name: 'Short Pants2',
+      description: '',
+      pieces: 1,
+      modifiersTotalAmount: 0,
+      total: 510,
+      totalPaid: 0,
+      price: 10,
+      quantity: 1,
+      path: ',68eeba20cbfa2b080d75f7ea,68eeba2d9366a6367d7baaea,',
+      notes: [],
+      serial: null,
+      sku: '',
+      modifiers: [
+        {
+          _id: '690a3d23de696e15c594f7f2',
+          attributes: ['department'],
+          modifierId: '68efd827aeec0b1c557f79d4',
+          _parentId: null,
+          locked: false,
+          name: 'Dry Cleaning',
+          sku: '',
+          description: '',
+          group: '',
+          type: '',
+          tags: ['default'],
+          order: 0,
+          included: false,
+          direct: true,
+          hidden: false,
+          print: true,
+          required: false,
+          recommended: false,
+          default: false,
+          code: 'DC',
+          properties: {
+            department: {
+              tagSize: 'small',
+              splitUnit: 'quantity',
+              maxItems: '',
+              autoSplit: false,
+            },
+            sort: null,
+          },
+          _computed: {
+            amount: 0,
+            description: 'Dry Cleaning',
+          },
+          conditions: {
+            valid: true,
+          },
+          compute: null,
+          _createdAt: '2025-10-15T17:21:43.526Z',
+          _updatedAt: '2025-10-15T17:26:13.671Z',
+          __typename: 'Modifier',
+          addModifiers: [],
+          delModifiers: [],
+        },
+        {
+          _id: '690a3d2ede696e15c594f7f3',
+          attributes: ['override'],
+          modifierId: '690a195d3117c6cb92a692c0',
+          _parentId: null,
+          locked: false,
+          name: 'Pleats',
+          sku: '',
+          description: '',
+          group: '',
+          type: '',
+          tags: ['default'],
+          order: 0,
+          included: false,
+          direct: true,
+          hidden: false,
+          print: true,
+          required: false,
+          recommended: false,
+          default: false,
+          code: '',
+          properties: {
+            subscription: {},
+            override: {
+              field: 'amount',
+              type: 'manual',
+              options: null,
+              fixedValue: 20,
+              service: null,
+              unitAsAmountMultiplier: true,
+              amountMultiplier: 25,
+              multiplier: false,
+            },
+            group: {
+              items: [],
+              modifiers: [],
+            },
+            department: {},
+            sort: null,
+          },
+          _computed: {
+            amount: 500,
+            description: 'Pleats ($500.00)',
+          },
+          conditions: {
+            valid: true,
+          },
+          compute: {
+            type: 'fixed',
+            amount: 20,
+            action: 'add',
+          },
+          _createdAt: '2025-11-04T15:18:53.231Z',
+          _updatedAt: '2025-11-04T16:54:33.773Z',
+          __typename: 'Modifier',
+          addModifiers: [],
+          delModifiers: [],
+        },
+      ],
+      _id: '690a3d23de696e15c594f7f1',
+      _updatedAt: '2025-11-04T17:05:05.845Z',
+      _createdAt: '2025-10-14T21:02:10.991Z',
+      weight: 0,
+      properties: {},
+      hasInventory: true,
+      inventoryType: 'push',
+      serialRequired: false,
+      tags: [],
+      category: null,
+      __typename: 'OrderItem',
+      priceLevels: [
+        {
+          value: 10,
+          tags: ['default'],
+        },
+        {
+          value: 8,
+          tags: ['default', 'vip'],
+        },
+      ],
+      costLevels: [],
+      itemId: '68eeba52cbfa2b080d75fa02',
+      menuRuleId: '68eeba559366a6367d7bab08',
+      subTotals: {
+        _included: 0,
+        _xincluded: 500,
+        _direct: 500,
+        _xdirect: 0,
+        _simple: 10,
+        _actual: 10,
+        '': 500,
+      },
+    };
+    const calculatedItem = pricingService.item.calculate(item);
+    expect(calculatedItem.total).toBe(510);
+  });
 });

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',
@@ -253,11 +253,7 @@ describe('addItem function', () => {
     });
     expect(updatedOrder2.items[1]).toMatchObject({
       name: 'the parent item',
-      modifiers: [
-        {
-          name: 'General Repair Department',
-        },
-      ],
+      modifiers: [],
     });
 
     const relatedItem2 = {
@@ -270,7 +266,7 @@ describe('addItem function', () => {
         relatedItem: true,
         parentItemId: updatedOrder.items[0].itemId,
         parentId: updatedOrder.items[0]._id,
-        includeParent: true,
+        repairOnly: false,
         addModifiers: [
           {
             _id: 'mod1',
@@ -295,11 +291,7 @@ describe('addItem function', () => {
     });
     expect(updatedOrder3.items[2]).toMatchObject({
       name: 'the parent item',
-      modifiers: [
-        {
-          name: 'General Repair Department',
-        },
-      ],
+      modifiers: [],
     });
   });
 });

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,9 @@ 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 itemActions = (deps = {}) => {
   const actions = {};
@@ -111,7 +112,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 +134,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 +160,9 @@ const itemActions = (deps = {}) => {
     isSerialRequired: isSerialRequired(innerDeps),
     isSerialLengthValid: isSerialLengthValid(innerDeps),
     getSerialStatus: getSerialStatus(innerDeps),
+    removeDepartmentModifiers: removeDepartmentModifiers(innerDeps),
+    isRemoveParentItem: isRemoveParentItem(innerDeps),
+    hasRelatedItems: hasRelatedItems(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/calculate.js

@@ -70,6 +70,14 @@ module.exports = ({ _, constants, utils, actions }) => {
         _computed.amount = math.mul(_computed.amount, options.quantity);
       }
 
+      if (
+        actions.isAmountOverride(_modifier) &&
+        actions.isAmountMultiplier(_modifier)
+      ) {
+        const amountMultiplier = actions.getAmountMultiplier(_modifier);
+        _computed.amount = math.mul(_computed.amount, amountMultiplier);
+      }
+
       if (actions.isTotalOverride(_modifier)) {
         _computed.amount = math.sub(compute.amount, options.maxDiscountAmount);
       }

package/lib/modifier/getAmountMultiplier.js

@@ -0,0 +1,10 @@
+module.exports = ({ actions }) =>
+  function getAmountMultiplier(modifier) {
+    if (!actions.isOverride(modifier)) return 1;
+    if (!actions.isAmountMultiplier(modifier)) return 1;
+
+    return (
+      (modifier.properties && modifier.properties.override.amountMultiplier) ||
+      1
+    );
+  };

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

@@ -179,6 +179,9 @@ const isEmptyOverride = require('./isEmptyOverride');
 const getMaxUsesPerCustomer = require('./getMaxUsesPerCustomer');
 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 = {};
@@ -370,6 +373,9 @@ const modifierActions = (deps = {}) => {
     getMaxUsesPerCustomer: getMaxUsesPerCustomer(innerDeps),
     getPromoCustomerIds: getPromoCustomerIds(innerDeps),
     getCountPerCustomer: getCountPerCustomer(innerDeps),
+    getAmountMultiplier: getAmountMultiplier(innerDeps),
+    isAmountMultiplier: isAmountMultiplier(innerDeps),
+    isRemoveParentItem: isRemoveParentItem(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isAmountMultiplier.js

@@ -0,0 +1,10 @@
+module.exports = () =>
+  function isAmountMultiplier(modifier) {
+    if (!modifier) return false;
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.override &&
+      modifier.properties.override.unitAsAmountMultiplier
+    );
+  };

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,37 +265,6 @@ 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
-      );
-    }
-
     return {
       updatedOrder: nextOrder,
       itemIndex: nextItemIndex,

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/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,8 @@ 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 orderActions = (deps = {}) => {
   const actions = {};
@@ -195,6 +197,8 @@ const orderActions = (deps = {}) => {
     isFullyPaid: isFullyPaid(innerDeps),
     getUpdatedStatus: getUpdatedStatus(innerDeps),
     setPieces: setPieces(innerDeps),
+    copyItemToParents: copyItemToParents(innerDeps),
+    getItemsWithParents: getItemsWithParents(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.130",
+  "version": "1.0.132",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -52,5 +52,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "a2d90179e995ae985e8b6843a1143dda0e874850"
+  "gitHead": "aa74813e6d89c8f6befeebeb07ebaaefef8e5d31"
 }

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

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

package/lib/item/hasAddModifiers.js

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

package/lib/item/isParentIncluded.js

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