@darkpos/pricing 1.0.75 → 1.0.76

package/__TEST__/item/unpick.item.test.js

@@ -0,0 +1,21 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+describe('Item actions - unpick item', () => {
+  test('unpick item', () => {
+    const orderItem = {
+      price: 30,
+      quantity: 2,
+      status: { picked: { value: true, date: new Date() } },
+    };
+
+    const newItem = pricingService.item.unpickItem(orderItem);
+    expect(newItem.status.picked).toStrictEqual({ value: false, date: '' });
+  });
+});

package/__TEST__/order/unpick.order.test.js

@@ -0,0 +1,97 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+describe('Order actions - unpick order', () => {
+  test('unpick items in parent order', () => {
+    const orderItem = {
+      price: 30,
+      quantity: 2,
+      status: { picked: { value: true, date: new Date() } },
+    };
+    const order = { items: [orderItem], status: { fullyPicked: true } };
+    const newOrder = pricingService.order.unpickOrder(order);
+    expect(newOrder.status.fullyPicked).toBe(false);
+    newOrder.items.map(item =>
+      expect(item.status.picked).toStrictEqual({ value: false, date: '' })
+    );
+  });
+  test('unpick 10 items in parent order', () => {
+    const orderItem = {
+      price: 30,
+      quantity: 2,
+      status: { picked: { value: true, date: new Date() } },
+    };
+    const order = {
+      status: { fullyPicked: true },
+      items: [
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+        orderItem,
+      ],
+    };
+    const newOrder = pricingService.order.unpickOrder(order);
+    expect(newOrder.status.fullyPicked).toBe(false);
+    newOrder.items.map(item =>
+      expect(item.status.picked).toStrictEqual({ value: false, date: '' })
+    );
+  });
+  test('unpick items in parent order with items that are not picked', () => {
+    const orderItem = {
+      price: 30,
+      quantity: 2,
+      status: { picked: { value: true, date: new Date() } },
+    };
+    const orderItemNotPicked = {
+      price: 30,
+      quantity: 2,
+      status: { picked: { value: false, date: '' } },
+    };
+    const order = {
+      items: [orderItem, orderItemNotPicked],
+      status: { fullyPicked: true },
+    };
+    const newOrder = pricingService.order.unpickOrder(order);
+    expect(newOrder.status.fullyPicked).toBe(false);
+    newOrder.items.map(item =>
+      expect(item.status.picked).toStrictEqual({ value: false, date: '' })
+    );
+  });
+
+  test('unpick items in parent order with items and suborder with items picked', () => {
+    const orderItem = {
+      price: 30,
+      quantity: 2,
+      status: { picked: { value: true, date: new Date() } },
+    };
+
+    const subOrder = { items: [orderItem], status: { fullyPicked: true } };
+    const order = {
+      items: [orderItem],
+      orders: [subOrder],
+      status: { fullyPicked: true },
+    };
+    const newOrder = pricingService.order.unpickOrder(order);
+    newOrder.items.map(item =>
+      expect(item.status.picked).toStrictEqual({ value: false, date: '' })
+    );
+    newOrder.orders.map(_order => {
+      expect(_order.status.fullyPicked).toBe(false);
+      return _order.items.map(item =>
+        expect(item.status.picked).toStrictEqual({ value: false, date: '' })
+      );
+    });
+  });
+});

package/lib/item/getPipeModifiers.js

@@ -3,7 +3,7 @@ module.exports = ({ modifierActions }) =>
     if (!item || !Array.isArray(item.modifiers)) return [];
     return item.modifiers.filter(
       modifier =>
-        modifierActions.isGroupOfModifiers(modifier) &&
+        modifierActions.isGroup(modifier) &&
         modifierActions.isRequired(modifier) &&
         modifierActions.enableAutoPopup(modifier)
     );

package/lib/item/getRelatedModifiers.js

@@ -0,0 +1,14 @@
+module.exports = ({ modifierActions }) =>
+  function getRelatedModifiers({ item }) {
+    if (!item || !Array.isArray(item.modifiers)) return [];
+
+    const relatedModifiers = [];
+
+    item.modifiers.forEach(itemMod => {
+      if (modifierActions.isRelatedModifier(itemMod)) {
+        relatedModifiers.push(itemMod);
+      }
+    });
+
+    return relatedModifiers;
+  };

package/lib/item/hasModifier.js

@@ -2,15 +2,6 @@ module.exports = ({ modifierActions }) =>
   function hasModifier({ item, modifier, relatedItems }) {
     if (!item || !modifier || !item.modifiers) return false;
 
-    const isGroupPath = groupPath =>
-      groupPath &&
-      (groupPath.includes(modifier.modifierId) ||
-        groupPath.includes(modifier._id));
-
-    const isSpreadFrom = spreadFromId =>
-      spreadFromId &&
-      (spreadFromId === modifier.modifierId || spreadFromId === modifier._id);
-
     if (modifierActions.isGroup(modifier)) {
       const matchByRelatedModifier = item.modifiers.some(itemMod => {
         if (
@@ -20,8 +11,14 @@ module.exports = ({ modifierActions }) =>
         )
           return false;
         return (
-          isGroupPath(itemMod.properties.groupPath) ||
-          isSpreadFrom(itemMod.properties.spreadFrom)
+          modifierActions.isGroupPath({
+            groupPath: itemMod.properties.groupPath,
+            modifier,
+          }) ||
+          modifierActions.isSpreadFrom({
+            spreadFromId: itemMod.properties.spreadFrom,
+            modifier,
+          })
         );
       });
 
@@ -29,9 +26,11 @@ module.exports = ({ modifierActions }) =>
         !!relatedItems &&
         modifierActions.isGroup(modifier) &&
         relatedItems.some(relatedItem =>
-          isGroupPath(
-            relatedItem.properties && relatedItem.properties.groupPath
-          )
+          modifierActions.isGroupPath({
+            groupPath:
+              relatedItem.properties && relatedItem.properties.groupPath,
+            modifier,
+          })
         );
 
       return matchByRelatedModifier || matchByRelatedItems;

package/lib/item/index.js

@@ -50,6 +50,8 @@ const getLastLocation = require('./getLastLocation');
 const hasAddModifiers = require('./hasAddModifiers');
 const getAddModifiers = require('./getAddModifiers');
 const getRelatedItems = require('./getRelatedItems');
+const getRelatedModifiers = require('./getRelatedModifiers');
+const unpickItem = require('./unpick');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -113,6 +115,8 @@ const itemActions = (deps = {}) => {
     hasAddModifiers: hasAddModifiers(innerDeps),
     getAddModifiers: getAddModifiers(innerDeps),
     getRelatedItems: getRelatedItems(innerDeps),
+    getRelatedModifiers: getRelatedModifiers(innerDeps),
+    unpickItem: unpickItem(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/removeModifier.js

@@ -15,7 +15,7 @@ module.exports = ({ modifierActions, _, actions }) => {
 
     if (!isValid(itemModifiers, modifier)) return item;
 
-    const addModifiers = modifierActions.getRelatedModifiers({
+    const addModifiers = modifierActions.getAddModifiers({
       modifier,
     });
 

package/lib/item/unpick.js

@@ -0,0 +1,15 @@
+module.exports = () =>
+  function unpickItem(item) {
+    if (!item) return item;
+    const nextItem = { ...item };
+    if (nextItem.status) {
+      nextItem.status = {
+        ...nextItem.status,
+        picked: {
+          value: false,
+          date: '',
+        },
+      };
+    }
+    return nextItem;
+  };

package/lib/modifier/getAddModifiers.js

@@ -0,0 +1,6 @@
+module.exports = () =>
+  function getAddModifiers({ modifier }) {
+    if (!modifier || !modifier.addModifiers) return [];
+
+    return modifier.addModifiers;
+  };

package/lib/modifier/getItemModifiers.js

@@ -11,7 +11,7 @@ module.exports = ({ actions }) =>
 
     const relatedModifiers = enabledModifiers
       .map(each =>
-        actions.getRelatedModifiers({
+        actions.getAddModifiers({
           modifier: each,
         })
       )

package/lib/modifier/getRelatedModifiers.js

@@ -1,8 +1,28 @@
-module.exports = () =>
-  function getRelatedModifiers({ modifier }) {
-    if (!modifier || !modifier.addModifiers) return [];
+module.exports = ({ actions }) =>
+  function getRelatedModifiers({ groupModifier, modifiers }) {
+    if (!actions.isGroup(groupModifier) || !Array.isArray(modifiers)) return [];
 
-    const relatedModifiers = modifier.addModifiers;
+    const relatedModifiers = [];
+
+    const otherModifiers = modifiers.filter(
+      mod =>
+        !actions.isGroup(mod) && mod._id !== groupModifier._id && mod.properties
+    );
+
+    otherModifiers.forEach(mod => {
+      if (
+        actions.isGroupPath({
+          groupPath: mod.properties.groupPath,
+          modifier: groupModifier,
+        }) ||
+        actions.isSpreadFrom({
+          spreadFromId: mod.properties.spreadFrom,
+          modifier: groupModifier,
+        })
+      ) {
+        relatedModifiers.push(mod);
+      }
+    });
 
     return relatedModifiers;
   };

package/lib/modifier/index.js

@@ -43,7 +43,7 @@ const getPreferences = require('./getPreferences');
 const getPromotionModifiers = require('./getPromotionModifiers');
 const getPromptMessage = require('./getPromptMessage');
 const getProperty = require('./getProperty');
-const getRelatedModifiers = require('./getRelatedModifiers');
+const getAddModifiers = require('./getAddModifiers');
 const getRecommendedModifiers = require('./getRecommendedModifiers');
 const getRequiredModifiers = require('./getRequiredModifiers');
 const getSubscriptionItem = require('./getSubscriptionItem');
@@ -114,7 +114,7 @@ const isFixedDiscount = require('./isFixedDiscount');
 const removeLocked = require('./removeLocked');
 const hasItems = require('./hasItems');
 const removeGroupData = require('./removeGroupData');
-const isRelatedModifier = require('./isRelatedModifier');
+const isRelatedModifierById = require('./isRelatedModifierById');
 const getGroupedModifiers = require('./getGroupedModifiers');
 const isOptionsOverride = require('./isOptionsOverride');
 const getGroupedModifierLabels = require('./getGroupedModifierLabels');
@@ -146,6 +146,10 @@ const removeGroupRelations = require('./removeGroupRelations');
 const getManualModifiers = require('./getManualModifiers');
 const shouldSpreadModifier = require('./shouldSpreadModifier');
 const spreadSingleGroupModifiers = require('./spreadSingleGroupModifiers');
+const isGroupPath = require('./isGroupPath');
+const isSpreadFrom = require('./isSpreadFrom');
+const getRelatedModifiers = require('./getRelatedModifiers');
+const isRelatedModifier = require('./isRelatedModifier');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -201,7 +205,7 @@ const modifierActions = (deps = {}) => {
     getPromotionModifiers: getPromotionModifiers(innerDeps),
     getPromptMessage: getPromptMessage(innerDeps),
     getProperty: getProperty(innerDeps),
-    getRelatedModifiers: getRelatedModifiers(innerDeps),
+    getAddModifiers: getAddModifiers(innerDeps),
     getRecommendedModifiers: getRecommendedModifiers(innerDeps),
     getRequiredModifiers: getRequiredModifiers(innerDeps),
     getSubscriptionItem: getSubscriptionItem(innerDeps),
@@ -271,7 +275,7 @@ const modifierActions = (deps = {}) => {
     isAdd: isAdd(innerDeps),
     mutateModifier: mutateModifier(innerDeps),
     removeGroupData: removeGroupData(innerDeps),
-    isRelatedModifier: isRelatedModifier(innerDeps),
+    isRelatedModifierById: isRelatedModifierById(innerDeps),
     getGroupedModifiers: getGroupedModifiers(innerDeps),
     isOptionsOverride: isOptionsOverride(innerDeps),
     getGroupedModifierLabels: getGroupedModifierLabels(innerDeps),
@@ -305,6 +309,10 @@ const modifierActions = (deps = {}) => {
     getManualModifiers: getManualModifiers(innerDeps),
     shouldSpreadModifier: shouldSpreadModifier(innerDeps),
     spreadSingleGroupModifiers: spreadSingleGroupModifiers(innerDeps),
+    isGroupPath: isGroupPath(innerDeps),
+    isSpreadFrom: isSpreadFrom(innerDeps),
+    getRelatedModifiers: getRelatedModifiers(innerDeps),
+    isRelatedModifier: isRelatedModifier(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isGroupPath.js

@@ -0,0 +1,8 @@
+module.exports = () =>
+  function isGroupPath({ groupPath, modifier }) {
+    return (
+      groupPath &&
+      (groupPath.includes(modifier.modifierId) ||
+        groupPath.includes(modifier._id))
+    );
+  };

package/lib/modifier/isRelatedModifier.js

@@ -1,13 +1,5 @@
-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;
+module.exports = () =>
+  function isRelatedModifier(modifier) {
+    if (!modifier || !modifier.properties) return false;
+    return !!modifier.properties.groupPath || modifier.properties.spreadFrom;
   };

package/lib/modifier/isRelatedModifierById.js

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

package/lib/modifier/isSpreadFrom.js

@@ -0,0 +1,7 @@
+module.exports = () =>
+  function isSpreadFrom({ spreadFromId, modifier }) {
+    return (
+      spreadFromId &&
+      (spreadFromId === modifier.modifierId || spreadFromId === modifier._id)
+    );
+  };

package/lib/order/addItemModifier.js

@@ -249,7 +249,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     // Recursive Rules:
     if (modifierActions.hasAddModifiers(modifier)) {
       const relatedModifiers = modifierActions
-        .getRelatedModifiers({ modifier })
+        .getAddModifiers({ modifier })
         .filter(each => !modifierActions.contains(item.modifiers, each));
 
       item = relatedModifiers.reduce(

package/lib/order/index.js

@@ -38,6 +38,7 @@ const toggleModifier = require('./toggleModifier');
 const voidOrder = require('./void');
 const holdOrder = require('./hold');
 const openOrder = require('./open');
+const unpickOrder = require('./unpick');
 const isDetailed = require('./isDetailed');
 const splitByDepartments = require('./splitByDepartments');
 const autoSplit = require('./autoSplit');
@@ -138,6 +139,7 @@ const orderActions = (deps = {}) => {
     voidOrder: voidOrder(innerDeps),
     holdOrder: holdOrder(innerDeps),
     openOrder: openOrder(innerDeps),
+    unpickOrder: unpickOrder(innerDeps),
     isDetailed: isDetailed(innerDeps),
     splitByDepartments: splitByDepartments(innerDeps),
     autoSplit: autoSplit(innerDeps),

package/lib/order/unpick.js

@@ -0,0 +1,28 @@
+module.exports = ({ itemActions }) =>
+  function unpickOrder(order) {
+    if (!order) return order;
+    const nextOrder = { ...order };
+    if (order.items.length > 0) {
+      const orderItems = [...(order.items || [])].map(item =>
+        itemActions.unpickItem(item)
+      );
+      if (nextOrder.status && nextOrder.status.fullyPicked) {
+        nextOrder.status.fullyPicked = false;
+      }
+      nextOrder.items = orderItems;
+    }
+    if (order.orders && order.orders.length > 0) {
+      const suborderWithItems = order.orders.map(_order => {
+        const nextsubOrder = {
+          ..._order,
+          items: _order.items.map(item => itemActions.unpickItem(item)),
+        };
+        if (nextsubOrder.status && nextsubOrder.status.fullyPicked) {
+          nextsubOrder.status.fullyPicked = false;
+        }
+        return nextsubOrder;
+      });
+      nextOrder.orders = suborderWithItems;
+    }
+    return nextOrder;
+  };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.75",
+  "version": "1.0.76",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -51,5 +51,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "b0331c1d450926e0feb4f79146c6dd4f81e5af61"
+  "gitHead": "195250ff6ff1f2b38a7c47003006b8d2dcb2048b"
 }