@darkpos/pricing 1.0.66 → 1.0.68

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

@@ -1,6 +1,6 @@
-module.exports = ({ modifierActions }) =>
-  function getInvalidRequiredModifiers({ item }) {
-    if (!item || !Array.isArray(item.modifiers)) return true;
+module.exports = ({ modifierActions, actions }) =>
+  function getInvalidRequiredModifiers({ item, otherItems }) {
+    if (!item || !Array.isArray(item.modifiers)) return [];
     const invalidModifiers = [];
 
     item.modifiers.forEach(modifier => {
@@ -14,7 +14,16 @@ module.exports = ({ modifierActions }) =>
               _id: itemModifier.modifierId || itemModifier._id,
               modifier,
             })
+          ) &&
+        Array.isArray(otherItems) &&
+        modifierActions.isGroupOfItems(modifier) &&
+        !modifier.properties.group.items.some(relatedItem =>
+          otherItems.some(
+            otherItem =>
+              actions.isRelatedItem(otherItem) &&
+              otherItem.itemId === relatedItem._id
           )
+        )
       ) {
         invalidModifiers.push(modifier);
       }

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,38 @@
 module.exports = ({ modifierActions }) =>
-  function hasModifier({ item, modifier }) {
+  function hasModifier({ item, modifier, relatedItems, originalModifier }) {
     if (!item || !modifier || !item.modifiers) return false;
 
+    console.log({ item, modifier, relatedItems });
+
+    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,61 @@
 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,
+    });
+
+    console.log(item, '<=====', actions.getRelatedItems({ order, item }));
+
+    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 => {