@darkpos/pricing 1.0.66 → 1.0.68

package/lib/order/removeItem.js

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

package/lib/order/removeModifier.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.66",
+  "version": "1.0.68",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -20,10 +20,12 @@
     "test:split": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/split.test.js",
     "test:getModifierTags": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/item/getModifierTags.test.js",
     "test:createIndirectModifier": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/modifier/createIndirectModifier.test.js",
+    "test:getInvalidRequiredModifiers": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/modifier/getInvalidRequiredModifiers",
     "test:conditionsNotMet": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/conditionsNotMet.test.js",
     "test:pickEndDate": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/pickEndDate.test.js",
     "test:modifier": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/modifier.test.js",
     "test:paymentModifiers": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/order-payment-modifier.test.js",
+    "test:addItem": "jest --runInBand --detectOpenHandles --logHeapUsage  --forceExit ./__TEST__/order/addItem.test.js",
     "lint": "eslint --quiet lib/"
   },
   "publishConfig": {
@@ -47,5 +49,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "d007d8455487fed168f127c6b338dc4301a7da79"
+  "gitHead": "ac976fa76195b19e32645c5defe5df41c867609c"
 }

package/lib/item/removePaymentModifiers.js

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

package/lib/order/addDiscountModifier.js

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

package/lib/order/removeDiscountModifier.js

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