@darkpos/pricing 1.0.15 → 1.0.17

package/lib/order/addItem.js

@@ -127,126 +127,124 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
     // Default modifiers
     if (idx === undefined && !_.isEmpty(item.modifiers))
       modifiersToAdd.push(
-        ...item.modifiers.map(each => modifierActions.create(each))
+        ...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);
-        }
+  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);
       }
     }
+  }
 
-    if (overridenQuantity > -1) {
-      orderItem.quantity = overridenQuantity;
-    }
-
-    if (!combined) {
-      // add price
-      orderItem.price = itemActions.getItemPrice({
-        cache,
-        customer,
-        item: orderItem,
-      });
-      if (itemActions.isRelatedItem(orderItem)) {
-        // console.log('CHECKING Parent ...', orderItem.properties);
-        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 });
-        }
-      }
-    }
+  if (overridenQuantity > -1) {
+    orderItem.quantity = overridenQuantity;
+  }
 
-    // add modifiers
-    let requiredModifiers = modifierActions.getItemModifiers({
-      modifiers: itemModifiers,
-      customer,
+  if (!combined) {
+    // add price
+    orderItem.price = itemActions.getItemPrice({
       cache,
+      customer,
+      item: orderItem,
     });
-    // 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
-            )
-        )
-      );
+    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 });
+      }
     }
+  }
 
-    orderItem = actions.getOrderItemSubscriptions({
-      order,
-      item: orderItem,
-      combined,
-      cache,
-    });
+  // 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
+          )
+      )
+    );
+  }
 
-    const params = addOrderItem({
-      order,
-      item: orderItem,
-      itemIndex: idx,
-    });
-    let [nextOrder, nextItemIndex] = params;
-    const [, , nextItem] = params;
-
-    if (modifiersToAdd.length) {
-      // console.log('Adding Modifier to the item index ...', nextItemIndex);
-      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/addItemModifier.js

@@ -135,7 +135,6 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
       modifierActions.isTrackUsageSubscription(modifier) &&
       !itemActions.hasCreateSubscription(order.items)
     ) {
-      // console.log('Removing UsageTracker Modifier ...');
       return order;
     }
     // Remove if it has it already only if it is not group of value or override modifier
@@ -147,7 +146,6 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
         modifierActions.isOverride(modifier)
       )
     ) {
-      // console.log('Removing MODIFIER ...');
       order = actions.removeItemModifier({
         order,
         modifier,
@@ -188,7 +186,6 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     order.items[itemIndex] = item;
 
     if (modifierActions.hasRelatedItems(modifier)) {
-      // console.log('Adding related Items ...', modifier.properties.group.items);
       order = modifier.properties.group.items.reduce((acc, each) => {
         const [nextOrder] = actions.addItem({
           item: {

package/lib/order/addModifier.js

@@ -1,9 +1,21 @@
-module.exports = ({ modifierActions }) =>
+module.exports = ({ actions, modifierActions }) =>
   function addModifier({ order, modifier }) {
     if (!modifier) return order;
     const { modifiers = [] } = order;
+
+    if (modifierActions.isFixedDiscount(modifier)) {
+      const orderDue = actions.calculateDue(order);
+      if (modifier.compute.amount > orderDue) {
+        const err = new Error();
+        err.valid = false;
+        err.orderDue = orderDue;
+        err.message = 'discount.can.not.be.applied.order.due.is.this.amount';
+        throw err;
+      }
+    }
+
     return {
       ...order,
-      modifiers: [...modifiers, modifierActions.create(modifier)],
+      modifiers: [...modifiers, { ...modifier }],
     };
   };

package/lib/order/addModifiers.js

@@ -0,0 +1,15 @@
+module.exports = ({ actions }) =>
+  function addModifiers({ order, modifiers }) {
+    if (!Array.isArray(modifiers) || modifiers.length === 0) return order;
+
+    return modifiers.reduce(
+      (nextOrder, modifier) =>
+        actions.addModifier({
+          modifier: {
+            ...modifier,
+          },
+          order: nextOrder,
+        }),
+      order
+    );
+  };

package/lib/order/autoSplit.js

@@ -0,0 +1,34 @@
+module.exports = ({ actions }) =>
+  function autoSplit({ parentOrder }) {
+    let subOrders = parentOrder.orders || [];
+    let newSubOrders = [];
+    const existingItems = subOrders
+      .map(subOrder => subOrder.items || [])
+      .flat();
+    const newItems = parentOrder.items.filter(item => {
+      const existingItem = existingItems.find(
+        eItem => String(eItem._id) === String(item._id)
+      );
+      return !existingItem;
+    });
+
+    if (newItems.length > 0) {
+      newSubOrders = actions.splitByDepartments({
+        ...parentOrder,
+        items: newItems,
+      });
+    }
+
+    // reassign displayIds
+    subOrders = [...subOrders, ...newSubOrders].map((subOrder, idx) => ({
+      ...subOrder,
+      displayId: `${parentOrder.displayId}-${idx + 1}`,
+    }));
+
+    subOrders = actions.spreadModifiers({
+      parentOrder,
+      subOrders,
+    });
+
+    return subOrders;
+  };

package/lib/order/calculate.js

@@ -2,90 +2,68 @@
 /**
  * return calculated Order
  */
-module.exports = ({ _, utils, itemActions, modifierActions }) => {
-  const { math } = utils;
-
-  const pricing = items => {
-    let subTotals = {};
-    let subTotal = 0;
-
-    for (const item of items) {
-      subTotal = math.add(subTotal, item.subTotals._actual);
-      const keys = Object.keys(item.subTotals).filter(
-        key => !key.includes('_')
-      );
-      for (const key of keys) {
-        subTotals[key] = math.add(subTotals[key] || 0, item.subTotals[key]);
-      }
-    }
-
-    const total = Object.keys(subTotals).reduce(
-      (acc, key) => math.add(acc, subTotals[key]),
-      subTotal
-    );
-
-    subTotals = Object.keys(subTotals).reduce(
-      (acc, key) => ({
-        ...acc,
-        [key]: subTotals[key],
-      }),
-      {}
-    );
-
-    return {
-      subTotals,
-      subTotal,
-      total,
-    };
-  };
-
-  const getItems = (items, orderModifiers) => {
-    const existsInOrderModifier = modifier =>
-      orderModifiers &&
-      orderModifiers.find(each => each.modifierId === modifier.modifierId);
-
-    return items.map(item => {
-      const modifiers = (item.modifiers || []).filter(
-        modifier => !existsInOrderModifier(modifier)
-      );
-      return {
-        ...item,
-        modifiers,
-      };
-    });
-  };
-
-  return function calculateorder(inputOrder) {
+module.exports = ({ _, itemActions, modifierActions }) =>
+  function calculateorder(inputOrder) {
     if (!inputOrder) return inputOrder;
     const order = _.cloneDeep(inputOrder);
     const { items = [] } = order;
+
     if (!items.length)
       return { ...order, subTotals: {}, subTotal: 0, total: 0 };
 
-    const modifiers = _.uniqBy(order.modifiers, '_id');
-    // if there is no order level modifiers, we have to remove them from items
-    let itemsWNIM = getItems(items, modifiers);
+    const orderModifiers = modifierActions.removeLocked(order.modifiers);
+
+    let itemsWNIM = items.map(item =>
+      itemActions.removeModifiers({ item, modifiers: orderModifiers })
+    );
+
     itemsWNIM = itemActions.calculate(itemsWNIM);
-    const newOrder = { ...order, ...pricing(itemsWNIM), items: itemsWNIM };
 
-    if (!modifiers.length) return newOrder;
+    const newOrder = {
+      ...order,
+      ...itemActions.getTotals(itemsWNIM),
+      items: itemsWNIM,
+    };
+
+    if (!orderModifiers.length) return newOrder;
 
     const newItems = itemsWNIM || items;
     let itemsWIM = _.cloneDeep(newItems);
 
     let computedTotal = newOrder.total;
-    const sortedModifiers = modifierActions.sort(modifiers);
-    for (const modifier of sortedModifiers) {
+
+    for (const modifier of orderModifiers) {
       const isCredit = modifierActions.isCredit(modifier);
+      let tempItems = newItems;
+
       if (isCredit) {
         const calculatedItemWIM = itemActions.calculate(itemsWIM);
-        ({ total: computedTotal } = pricing(calculatedItemWIM));
+        computedTotal = itemActions.getTotals(calculatedItemWIM).total;
       }
-      const itemsModifiers = itemActions.addIndirectModifier(
-        computedTotal,
-        newItems,
-        modifier
+
+      const hasItems = modifierActions.hasItems({ modifier });
+
+      if (hasItems) {
+        tempItems = itemActions.getItems(tempItems, modifier.items);
+      }
+
+      tempItems = tempItems.map(tempItem =>
+        itemActions.removeModifiers({
+          item: tempItem,
+          modifiers: modifierActions.getLockedModifiers(tempItem.modifiers),
+        })
       );
+
+      tempItems = itemActions.calculate(tempItems);
+
+      computedTotal = itemActions.getTotals(tempItems).total;
+
+      const itemsModifiers = itemActions.addIndirectModifier({
+        orderTotal: computedTotal,
+        items: tempItems,
+        modifier,
+      });
+
       // adding the modifiers to items
       itemsWIM = itemsWIM.map(item => ({
         ...item,
@@ -96,10 +74,10 @@ module.exports = ({ _, utils, itemActions, modifierActions }) => {
     }
 
     const calculatedItemWIM = itemActions.calculate(itemsWIM);
+
     return {
       ...order,
-      ...pricing(calculatedItemWIM),
+      ...itemActions.getTotals(calculatedItemWIM),
       items: calculatedItemWIM,
     };
   };
-};

package/lib/order/getScheduleByCustomer.js

@@ -14,7 +14,6 @@ module.exports = ({ _, settings }) => {
       .filter(each => each !== 'default' && each !== 'all')
       .find(each => scheduleTags.includes(each));
     if (!tag) return defaultSchedule;
-    console.log('schedule for the tag', tag, schedules[tag]);
     return schedules[tag];
   };
 };

package/lib/order/index.js

@@ -42,6 +42,8 @@ const holdOrder = require('./hold');
 const openOrder = require('./open');
 const isDetailed = require('./isDetailed');
 const splitByDepartments = require('./splitByDepartments');
+const autoSplit = require('./autoSplit');
+const syncSubOrderItemsFromParent = require('./syncSubOrderItemsFromParent');
 const createParent = require('./createParent');
 const getOrdersPieces = require('./getOrdersPieces');
 const getTotals = require('./getTotals');
@@ -80,6 +82,9 @@ const splitAndCalculate = require('./splitAndCalculate');
 const spreadModifiers = require('./spreadModifiers');
 const validateCreditModifiersTotal = require('./validateCreditModifiersTotal');
 const validateFixedModifiersTotal = require('./validateFixedModifiersTotal');
+const markModifiersAsLocked = require('./markModifiersAsLocked');
+const removeModifiers = require('./removeModifiers');
+const addModifiers = require('./addModifiers');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -133,6 +138,8 @@ const orderActions = (deps = {}) => {
     openOrder: openOrder(innerDeps),
     isDetailed: isDetailed(innerDeps),
     splitByDepartments: splitByDepartments(innerDeps),
+    autoSplit: autoSplit(innerDeps),
+    syncSubOrderItemsFromParent: syncSubOrderItemsFromParent(innerDeps),
     createParent: createParent(innerDeps),
     getOrdersPieces: getOrdersPieces(innerDeps),
     getTotals: getTotals(innerDeps),
@@ -172,6 +179,9 @@ const orderActions = (deps = {}) => {
     spreadModifiers: spreadModifiers(innerDeps),
     validateCreditModifiersTotal: validateCreditModifiersTotal(innerDeps),
     validateFixedModifiersTotal: validateFixedModifiersTotal(innerDeps),
+    markModifiersAsLocked: markModifiersAsLocked(innerDeps),
+    removeModifiers: removeModifiers(innerDeps),
+    addModifiers: addModifiers(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/markModifiersAsLocked.js

@@ -0,0 +1,14 @@
+module.exports = ({ itemActions }) =>
+  function markModifiersAsLocked({ order, modifierIds }) {
+    if (!order || !Array.isArray(order.modifiers)) return {};
+
+    return {
+      ...order,
+      modifiers: order.modifiers.map(mod =>
+        modifierIds.includes(mod._id) ? { ...mod, locked: true } : mod
+      ),
+      items: (order.items || []).map(item =>
+        itemActions.markModifiersAsLocked({ item, modifierIds })
+      ),
+    };
+  };

package/lib/order/removeItem.js

@@ -22,7 +22,6 @@ module.exports = ({ actions, _, itemActions }) => {
       items[orderItemIdx] = { ...orderItem, price: 0, modifiers: [] };
       if (hasRelatedItem) {
         items = updateRelatedItems(items, item._id);
-        // console.log('Update related items ...', items);
       }
     }
     // Decrease the quantity
@@ -43,7 +42,6 @@ module.exports = ({ actions, _, itemActions }) => {
       const parent = itemActions.getParentItem(items, orderItem);
       const parentIndex = actions.getItemIndex({ order, item: parent });
       const siblings = actions.getRelatedItems({ order, item: parent });
-      // console.log('Removing parent item ...');
       if (siblings <= 1) items.splice(parentIndex, 1);
     }
 

package/lib/order/removeModifier.js

@@ -6,13 +6,17 @@ module.exports = ({ modifierActions, itemActions }) =>
       entity: order,
       modifier,
     });
+
     const nextOrder = { ...order };
 
     if (index > -1) {
       const { items, modifiers } = nextOrder;
       if (items)
         nextOrder.items = items.map(each =>
-          itemActions.removeModifier({ item: each, modifier: modifiers[index] })
+          itemActions.removeModifier({
+            item: each,
+            modifier: modifiers[index],
+          })
         );
 
       nextOrder.modifiers.splice(index, 1);

package/lib/order/removeModifiers.js

@@ -0,0 +1,18 @@
+module.exports = ({ actions }) =>
+  function removeModifiers({ order, modifiers }) {
+    let _order = {};
+
+    if (modifiers.length > 0)
+      _order = modifiers.reduce(
+        (nextOrder, modifier) =>
+          actions.removeModifier({
+            order: nextOrder,
+            modifier: {
+              ...modifier,
+            },
+          }),
+        order
+      );
+
+    return _order;
+  };

package/lib/order/splitByDepartments.js

@@ -1,11 +1,4 @@
-module.exports = ({
-  utils,
-  _,
-  actions,
-  itemActions,
-  modifierActions,
-  settings,
-}) => {
+module.exports = ({ utils, _, itemActions, modifierActions, settings }) => {
   const orderSettings = _.get(settings, 'order');
   const { date, helpers } = utils;
   const noteDefaults = {
@@ -59,6 +52,15 @@ module.exports = ({
         displayId,
         discount: 0,
         tax: 0,
+        totalPaid: 0,
+        total: 0,
+        status: {
+          order: 'open',
+          delivery: order.status.delivery,
+          detailed: order.status.detailed,
+          fullyPaid: false,
+          fullyPicked: false,
+        },
         parentId: orderSettings.allowSuborder ? order._id : null,
         items,
         modifiers: [],
@@ -120,11 +122,6 @@ module.exports = ({
 
     splitOrders = joinItemQuantity(splitOrders);
 
-    splitOrders = actions.spreadModifiers({
-      parentOrder: order,
-      subOrders: splitOrders,
-    });
-
     return splitOrders;
   };
 };

package/lib/order/syncSubOrderItemsFromParent.js

@@ -0,0 +1,24 @@
+module.exports = () =>
+  function syncSubOrderItemsFromParent({ parentOrder }) {
+    const parentItems = parentOrder.items || [];
+    const subOrders = [...(parentOrder.orders || [])].map(subOrder => {
+      const items = subOrder.items
+        .map(cItem => {
+          const foundItem = parentItems.find(
+            pItem => String(pItem._id) === String(cItem._id)
+          );
+          return foundItem;
+        })
+        .filter(cItem => !!cItem);
+
+      return {
+        ...subOrder,
+        items,
+      };
+    });
+
+    return {
+      ...parentOrder,
+      orders: subOrders,
+    };
+  };