@darkpos/pricing 1.0.45 → 1.0.47

package/__TEST__/order/addItem.test.js

@@ -26,7 +26,11 @@ describe('addItem function', () => {
     };
 
     // Call the function
-    const [updatedOrder, itemIndex, addedItem] = addItem({
+    const {
+      updatedOrder,
+      itemIndex,
+      item: addedItem,
+    } = addItem({
       order,
       item,
       itemIndex: -1, // No existing item in order
@@ -67,7 +71,11 @@ describe('addItem function', () => {
     };
 
     // Call the function
-    const [updatedOrder, itemIndex, addedItem] = addItem({
+    const {
+      updatedOrder,
+      itemIndex,
+      item: addedItem,
+    } = addItem({
       order,
       item,
       itemIndex: -1, // Assuming no explicit index
@@ -99,7 +107,7 @@ describe('addItem function', () => {
     };
 
     // Call the function with an overridden quantity
-    const [updatedOrder, , addedItem] = addItem({
+    const { updatedOrder, item: addedItem } = addItem({
       order,
       item,
       itemIndex: -1, // Assuming no explicit index
@@ -153,7 +161,7 @@ describe('addItem function', () => {
         },
         {
           _id: '66cdf18a1e48455e128a4f64',
-          modifierId: 'mod2',
+          modifierId: null,
           _parentId: null,
           name: null,
           sku: null,
@@ -179,7 +187,7 @@ describe('addItem function', () => {
     };
 
     // Call the function
-    const [updatedOrder] = addItem({
+    const { updatedOrder } = addItem({
       order,
       item,
       itemIndex: -1, // Assuming no explicit index
@@ -190,9 +198,7 @@ describe('addItem function', () => {
     // Assertions
     expect(updatedOrder.items).toHaveLength(1); // Should have one item
     expect(updatedOrder.items[0].modifiers).toHaveLength(2); // Item should have two modifiers
-    expect(updatedOrder.items[0].modifiers[0].modifierId).toBe(
-      '66cdf18a1e48455e128a4f63'
-    ); // Check first modifier
+    expect(updatedOrder.items[0].modifiers[0].modifierId).toBe('mod1'); // Check first modifier
     expect(updatedOrder.items[0].modifiers[1].modifierId).toBe(
       '66cdf18a1e48455e128a4f64'
     ); // Check second modifier

package/lib/item/getInvalidRequiredModifiers.js

@@ -0,0 +1,24 @@
+module.exports = ({ modifierActions }) =>
+  function getInvalidRequiredModifiers({ item }) {
+    if (!item || !Array.isArray(item.modifiers)) return true;
+    const invalidModifiers = [];
+
+    item.modifiers.forEach(modifier => {
+      if (
+        modifierActions.isRequired(modifier) &&
+        modifierActions.isGroupOfModifiers(modifier) &&
+        !item.modifiers
+          .filter(mod => mod._id !== modifier._id)
+          .some(itemModifier =>
+            modifierActions.isRelatedModifier({
+              _id: itemModifier.modifierId || itemModifier._id,
+              modifier,
+            })
+          )
+      ) {
+        invalidModifiers.push(modifier);
+      }
+    });
+
+    return invalidModifiers;
+  };

package/lib/item/getItemModifiersDescription.js

@@ -10,7 +10,8 @@ module.exports = ({ modifierActions, _, settings }) =>
           modifierActions.isValid(each) &&
           !modifierActions.isAmountOverride(each) &&
           !modifierActions.isDepartment(each) &&
-          modifierActions.isDirect(each)
+          modifierActions.isDirect(each) &&
+          !modifierActions.isGroupOfModifiers(each)
       )
       .map(modifier => {
         const { name, _id, compute = {} } = modifier;

package/lib/item/getPipeModifiers.js

@@ -0,0 +1,10 @@
+module.exports = ({ modifierActions }) =>
+  function getPipeModifiers({ item }) {
+    if (!item || !Array.isArray(item.modifiers)) return [];
+    return item.modifiers.filter(
+      modifier =>
+        modifierActions.isGroupOfModifiers(modifier) &&
+        modifierActions.isRequired(modifier) &&
+        modifierActions.enableAutoPopup(modifier)
+    );
+  };

package/lib/item/hasModifier.js

@@ -1,15 +1,27 @@
-module.exports = () =>
+module.exports = ({ modifierActions }) =>
   function hasModifier({ item, modifier }) {
     if (!item || !modifier || !item.modifiers) return false;
 
-    const itemModifier = item.modifiers.find(
-      each =>
-        (each.modifierId &&
-          (each.modifierId === modifier.modifierId ||
-            each.modifierId === modifier._id)) ||
-        (typeof each.modifier === 'object' &&
-          each.modifier._id === modifier.modifierId)
-    );
+    if (modifierActions.isGroupOfModifiers(modifier)) {
+      const relatedModifiers = modifier.properties.group.modifiers;
+      return [
+        modifierActions.removeGroupData({ modifier }),
+        ...relatedModifiers,
+      ].some(relatedModifier =>
+        hasModifier({ item, modifier: relatedModifier })
+      );
+    }
+
+    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)
+      );
 
     return !!itemModifier;
   };

package/lib/item/hasModifiers.js

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

package/lib/item/index.js

@@ -9,7 +9,6 @@ const removeModifiers = require('./removeModifiers');
 const findOriginalItem = require('./findOriginalItem');
 const create = require('./create');
 const hasModifier = require('./hasModifier');
-const isSelected = require('./isSelected');
 const hasModifiers = require('./hasModifiers');
 const addIndirectModifier = require('./addIndirectModifier');
 const calculate = require('./calculate');
@@ -40,6 +39,8 @@ const hasPaymentMethodType = require('./hasPaymentMethodType');
 const removePaymentModifiersByPaymentId = require('./removePaymentModifiersByPaymentId');
 const hasPaymentModifierWithPaymentId = require('./hasPaymentModifierWithPaymentId');
 const getBalance = require('./getBalance');
+const getPipeModifiers = require('./getPipeModifiers');
+const getInvalidRequiredModifiers = require('./getInvalidRequiredModifiers');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -61,7 +62,6 @@ const itemActions = (deps = {}) => {
     findOriginalItem: findOriginalItem(innerDeps),
     create: create(innerDeps),
     hasModifier: hasModifier(innerDeps),
-    isSelected: isSelected(innerDeps),
     hasModifiers: hasModifiers(innerDeps),
     addIndirectModifier: addIndirectModifier(innerDeps),
     calculate: calculate(innerDeps),
@@ -93,6 +93,8 @@ const itemActions = (deps = {}) => {
       removePaymentModifiersByPaymentId(innerDeps),
     hasPaymentModifierWithPaymentId: hasPaymentModifierWithPaymentId(innerDeps),
     getBalance: getBalance(innerDeps),
+    getPipeModifiers: getPipeModifiers(innerDeps),
+    getInvalidRequiredModifiers: getInvalidRequiredModifiers(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/duplicate.js

@@ -5,7 +5,7 @@ module.exports = ({ utils }) => {
 
     return {
       ...modifier,
-      modifierId: modifier._id,
+      modifierId: modifier.modifierId || modifier._id,
       _id: helpers.getObjectID(),
     };
   };

package/lib/modifier/getGroupRelatedModifiers.js

@@ -19,7 +19,11 @@ module.exports = ({ actions }) => {
       return arr;
     }, []);
 
-    if (actions.includesInGroup(modifier)) groupModifiers.unshift(modifier);
+    if (actions.includesInGroup(modifier))
+      groupModifiers.unshift({
+        ...actions.removeGroupData({ modifier }),
+        required: false,
+      });
 
     return groupModifiers;
   };

package/lib/modifier/getItemModifiers.js

@@ -6,9 +6,7 @@ module.exports = ({ actions }) =>
     });
 
     const enabledModifiers = matchedModifiers.filter(
-      each =>
-        (actions.isDefault(each) || actions.isRequired(each)) &&
-        !(actions.isGroupOfValues(each) || actions.isGroupOfModifiers(each))
+      each => actions.isDefault(each) || actions.isRequired(each)
     );
 
     const relatedModifiers = enabledModifiers

package/lib/modifier/index.js

@@ -126,6 +126,8 @@ const mutateModifier = require('./mutateModifier');
 const isFixedDiscount = require('./isFixedDiscount');
 const removeLocked = require('./removeLocked');
 const hasItems = require('./hasItems');
+const removeGroupData = require('./removeGroupData');
+const isRelatedModifier = require('./isRelatedModifier');
 const getGroupedModifiers = require('./getGroupedModifiers');
 const getNotesToModifierTags = require('./getNotesToModifierTags');
 const isOptionsOverride = require('./isOptionsOverride');
@@ -281,6 +283,8 @@ const modifierActions = (deps = {}) => {
     isFee: isFee(innerDeps),
     isAdd: isAdd(innerDeps),
     mutateModifier: mutateModifier(innerDeps),
+    removeGroupData: removeGroupData(innerDeps),
+    isRelatedModifier: isRelatedModifier(innerDeps),
     getGroupedModifiers: getGroupedModifiers(innerDeps),
     getNotesToModifierTags: getNotesToModifierTags(innerDeps),
     isOptionsOverride: isOptionsOverride(innerDeps),

package/lib/modifier/isRelatedModifier.js

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

package/lib/modifier/removeGroupData.js

@@ -0,0 +1,20 @@
+module.exports = ({ constants }) => {
+  const { Modifier } = constants;
+
+  return function removeGroupData({ modifier }) {
+    if (!modifier) return modifier;
+
+    return {
+      ...modifier,
+      properties:
+        modifier.properties && modifier.properties.group
+          ? { ...modifier.properties, group: null }
+          : modifier.properties,
+      attributes: Array.isArray(modifier.attributes)
+        ? modifier.attributes.filter(
+            attribute => attribute !== Modifier.Attributes.GROUP
+          )
+        : modifier.attributes,
+    };
+  };
+};

package/lib/order/addItem.js

@@ -187,6 +187,7 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       !_.isEmpty(orderItem.modifiers)
     )
       requiredModifiers = getUnselectedModifiers(orderItem, requiredModifiers);
+
     if (!_.isEmpty(requiredModifiers)) {
       modifiersToAdd.push(
         ...requiredModifiers.filter(
@@ -213,17 +214,23 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
     let [nextOrder, nextItemIndex] = params;
     const [, , nextItem] = params;
 
+    const overrideModifiers = modifiersToAdd.filter(modToAdd =>
+      modifierActions.isOverride(modToAdd)
+    );
+
     if (modifiersToAdd.length) {
-      nextOrder = modifiersToAdd.reduce(
-        (acc, modifier) =>
-          actions.addItemModifier({
-            itemIndex: nextItemIndex,
-            order: acc,
-            modifier,
-            cache,
-          }),
-        nextOrder
-      );
+      nextOrder = modifiersToAdd
+        .filter(modToAdd => !modifierActions.isOverride(modToAdd))
+        .reduce(
+          (acc, modifier) =>
+            actions.addItemModifier({
+              itemIndex: nextItemIndex,
+              order: acc,
+              modifier,
+              cache,
+            }),
+          nextOrder
+        );
     }
 
     const { reArrangedOrder, newIndex } = reArrangeNewItem({
@@ -243,6 +250,11 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       nextOrder.items.splice(idxToRemove, 1);
     }
 
-    return [nextOrder, nextItemIndex, nextItem];
+    return {
+      updatedOrder: nextOrder,
+      itemIndex: nextItemIndex,
+      item: nextItem,
+      overrideModifiers,
+    };
   };
 };

package/lib/order/addItemModifier.js

@@ -173,7 +173,14 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     const customer = actions.getCustomer(order);
     const contains =
       !_.isEmpty(item.modifiers) &&
-      modifierActions.contains(item.modifiers, modifier);
+      modifierActions.contains(
+        item.modifiers.filter(
+          mod =>
+            !modifierActions.isRequired(mod) &&
+            !modifierActions.isGroupOfModifiers(mod)
+        ),
+        modifier
+      );
 
     const usingCount = contains
       ? modifierActions.getUsingCount(item.modifiers, modifier)
@@ -237,7 +244,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
 
     if (modifierActions.hasRelatedItems(modifier)) {
       order = modifier.properties.group.items.reduce((acc, each) => {
-        const [nextOrder] = actions.addItem({
+        const { updatedOrder: nextOrder } = actions.addItem({
           item: {
             ...each,
             itemId: each._id,

package/lib/order/updateItemQuantity.js

@@ -14,7 +14,7 @@ module.exports = ({ actions, settings, _ }) => {
       const updatedQuantity = reset
         ? quantity
         : parseInt(`${item.quantity}${quantity}`, 10);
-      return actions.updateItem({
+      const { updatedOrder } = actions.updateItem({
         order,
         itemIndex,
         item: {
@@ -22,6 +22,7 @@ module.exports = ({ actions, settings, _ }) => {
           quantity: updatedQuantity,
         },
       });
+      return updatedOrder;
     }
     if (isBefore) {
       return actions.addItem({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.45",
+  "version": "1.0.47",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -15,6 +15,7 @@
     "test:me": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/order-payment-modifier.test.js",
     "test:order": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/order.test.js",
     "test:validateConditions": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/validateConditionsCalculate.test.js",
+    "test:hasModifier": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/modifier/hasModifier.test.js",
     "lint": "eslint --quiet lib/"
   },
   "publishConfig": {
@@ -38,5 +39,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "3bfaa3655ef26d0dc0fb60bdc40caee1e3693ccb"
+  "gitHead": "98185abdf0b1e4c22098c17b8eb1fde30c673093"
 }

package/lib/item/isSelected.js

@@ -1,13 +0,0 @@
-module.exports = ({ modifierActions, actions }) =>
-  function isSelected({ item, modifier }) {
-    if (!item || !item.modifiers || !modifier) return false;
-    let hasModifier = actions.hasModifier({ item, modifier });
-
-    if (!hasModifier && modifierActions.isGroupOfModifiers(modifier))
-      hasModifier = actions.hasModifiers({
-        item,
-        modifiers: modifier.properties.group.modifiers,
-      });
-
-    return hasModifier;
-  };