@darkpos/pricing 1.0.19 → 1.0.21

package/lib/order/addItem.js

@@ -126,125 +126,123 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
 
     // Default modifiers
     if (idx === undefined && !_.isEmpty(item.modifiers))
-      modifiersToAdd.push(
-        ...item.modifiers.map(each => ({...each}))
-      );
-
-  const pendingItem = actions.getSelectedItem({ order, itemIndex });
-
-  if (pendingItem && pendingItem.isPending && !combined) {
-    idx = itemIndex;
-    combined = !!pendingItem.itemId;
-    orderItem.quantity = pendingItem.quantity;
-    orderItem.isPending = !orderItem.itemId;
-    // add inventory
-    if (pendingItem.inventory) {
-      const inventory = getInventory(pendingItem);
-      if (inventory) {
-        orderItem.inventory = inventory;
-        if (inventory.serial) orderItem.serial = inventory.serial;
-        const modifiers = modifierActions.getEntityModifiers(inventory);
-        if (!_.isEmpty(modifiers)) modifiersToAdd.push(...modifiers);
+      modifiersToAdd.push(...item.modifiers.map(each => ({ ...each })));
+
+    const pendingItem = actions.getSelectedItem({ order, itemIndex });
+
+    if (pendingItem && pendingItem.isPending && !combined) {
+      idx = itemIndex;
+      combined = !!pendingItem.itemId;
+      orderItem.quantity = pendingItem.quantity;
+      orderItem.isPending = orderItem.isPending || !orderItem.itemId;
+      // add inventory
+      if (pendingItem.inventory) {
+        const inventory = getInventory(pendingItem);
+        if (inventory) {
+          orderItem.inventory = inventory;
+          if (inventory.serial) orderItem.serial = inventory.serial;
+          const modifiers = modifierActions.getEntityModifiers(inventory);
+          if (!_.isEmpty(modifiers)) modifiersToAdd.push(...modifiers);
+        }
       }
     }
-  }
 
-  if (overridenQuantity > -1) {
-    orderItem.quantity = overridenQuantity;
-  }
+    if (overridenQuantity > -1) {
+      orderItem.quantity = overridenQuantity;
+    }
 
-  if (!combined) {
-    // add price
-    orderItem.price = itemActions.getItemPrice({
-      cache,
-      customer,
-      item: orderItem,
-    });
-    if (itemActions.isRelatedItem(orderItem)) {
-      const parent = itemActions.getParentItem(order.items, orderItem);
-      // get inherited modifiers
-      const inheritedModifiers = modifierActions.getInheritedModifiers({
-        parent,
-        child: item,
+    if (!combined) {
+      // add price
+      orderItem.price = itemActions.getItemPrice({
+        cache,
+        customer,
+        item: orderItem,
       });
-      if (!_.isEmpty(inheritedModifiers))
-        modifiersToAdd.push(...inheritedModifiers);
-      // Remove parent if it is only a repair Item
-      if (!itemActions.isParentIncluded(orderItem)) {
-        order = actions.removeItem({ order, item: parent, hard: false });
+      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)) {
+          order = actions.removeItem({ order, item: parent, hard: false });
+        }
       }
     }
-  }
 
-  // add modifiers
-  let requiredModifiers = modifierActions.getItemModifiers({
-    modifiers: itemModifiers,
-    customer,
-    cache,
-  });
-  // Do not add again if they are already there
-  if (
-    !_.isEmpty(requiredModifiers) &&
-    combined &&
-    !_.isEmpty(orderItem.modifiers)
-  )
-    requiredModifiers = getUnselectedModifiers(orderItem, requiredModifiers);
-  if (!_.isEmpty(requiredModifiers)) {
-    modifiersToAdd.push(
-      ...requiredModifiers.filter(
-        reqMod =>
-          !modifiersToAdd.find(
-            modToAdd => modToAdd.modifierId === reqMod.modifierId
-          )
-      )
-    );
-  }
+    // add modifiers
+    let requiredModifiers = modifierActions.getItemModifiers({
+      modifiers: itemModifiers,
+      customer,
+      cache,
+    });
+    // Do not add again if they are already there
+    if (
+      !_.isEmpty(requiredModifiers) &&
+      combined &&
+      !_.isEmpty(orderItem.modifiers)
+    )
+      requiredModifiers = getUnselectedModifiers(orderItem, requiredModifiers);
+    if (!_.isEmpty(requiredModifiers)) {
+      modifiersToAdd.push(
+        ...requiredModifiers.filter(
+          reqMod =>
+            !modifiersToAdd.find(
+              modToAdd => modToAdd.modifierId === reqMod.modifierId
+            )
+        )
+      );
+    }
 
-  orderItem = actions.getOrderItemSubscriptions({
-    order,
-    item: orderItem,
-    combined,
-    cache,
-  });
-
-  const params = addOrderItem({
-    order,
-    item: orderItem,
-    itemIndex: idx,
-  });
-  let [nextOrder, nextItemIndex] = params;
-  const [, , nextItem] = params;
-
-  if (modifiersToAdd.length) {
-    nextOrder = modifiersToAdd.reduce(
-      (acc, modifier) =>
-        actions.addItemModifier({
-          itemIndex: nextItemIndex,
-          order: acc,
-          modifier,
-          cache,
-        }),
-      nextOrder
-    );
-  }
+    orderItem = actions.getOrderItemSubscriptions({
+      order,
+      item: orderItem,
+      combined,
+      cache,
+    });
+
+    const params = addOrderItem({
+      order,
+      item: orderItem,
+      itemIndex: idx,
+    });
+    let [nextOrder, nextItemIndex] = params;
+    const [, , nextItem] = params;
+
+    if (modifiersToAdd.length) {
+      nextOrder = modifiersToAdd.reduce(
+        (acc, modifier) =>
+          actions.addItemModifier({
+            itemIndex: nextItemIndex,
+            order: acc,
+            modifier,
+            cache,
+          }),
+        nextOrder
+      );
+    }
 
-  const { reArrangedOrder, newIndex } = reArrangeNewItem({
-    nextOrder,
-    nextItemIndex,
-  });
+    const { reArrangedOrder, newIndex } = reArrangeNewItem({
+      nextOrder,
+      nextItemIndex,
+    });
 
-  if (reArrangedOrder && newIndex) {
-    nextOrder = { ...reArrangedOrder };
-    nextItemIndex = newIndex;
-  }
+    if (reArrangedOrder && newIndex) {
+      nextOrder = { ...reArrangedOrder };
+      nextItemIndex = newIndex;
+    }
 
-  // Need to delete any pending Items if the current was combined
+    // Need to delete any pending Items if the current was combined
 
-  if (combined && pendingItemIndex > -1 && idx !== itemIndex) {
-    const idxToRemove = actions.getPendingItemIndex(nextOrder);
-    nextOrder.items.splice(idxToRemove, 1);
-  }
+    if (combined && pendingItemIndex > -1 && idx !== itemIndex) {
+      const idxToRemove = actions.getPendingItemIndex(nextOrder);
+      nextOrder.items.splice(idxToRemove, 1);
+    }
 
-  return [nextOrder, nextItemIndex, nextItem];
-};
+    return [nextOrder, nextItemIndex, nextItem];
+  };
 };

package/lib/order/index.js

@@ -64,6 +64,7 @@ const hasItem = require('./hasItem');
 const getNumberOfItems = require('./getNumberOfItems');
 const isOpen = require('./isOpen');
 const isHold = require('./isHold');
+const isVoid = require('./isVoid');
 const addItemModifier = require('./addItemModifier');
 const removeItemModifier = require('./removeItemModifier');
 const addModifierToAllItems = require('./addModifierToAllItems');
@@ -161,6 +162,7 @@ const orderActions = (deps = {}) => {
     getNumberOfItems: getNumberOfItems(innerDeps),
     isOpen: isOpen(innerDeps),
     isHold: isHold(innerDeps),
+    isVoid: isVoid(innerDeps),
     getItemsToPay: getItemsToPay(innerDeps),
     addItemModifier: addItemModifier(innerDeps),
     removeItemModifier: removeItemModifier(innerDeps),

package/lib/order/isVoid.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isVoid(order) {
+    return !!(order && order.status && order.status.order === 'void');
+  };

package/lib/order/updateItemQuantity.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -36,5 +36,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "a5c473431af3c4cb39cfcd76b4367ad7cac9cf5a"
+  "gitHead": "30595eb4b38240679c45e5eff7ac875719e9dcd0"
 }