@darkpos/pricing 1.0.4 → 1.0.7

package/lib/order/getEndDate.js

@@ -0,0 +1,4 @@
+module.exports = ({ _ }) =>
+  function getEndDate({ order }) {
+    return _.get(order, 'end.requestDate', '');
+  };

package/lib/order/getItemByItemId.js

@@ -0,0 +1,6 @@
+module.exports = () =>
+  function getItemByItemId({ order = {}, itemId }) {
+    if (!order || !order.items) return null;
+    const item = order.items.find(each => each.itemId === itemId);
+    return item;
+  };

package/lib/order/getItemIndex.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function getItemIndex({ order, item }) {
+    if (!order || !order.items || !item) return -1;
+    return order.items.findIndex(each => {
+      if (!item.itemId && each.isPending) return item._id === each._id;
+
+      return each._id === item._id && each.itemId === item.itemId;
+    });
+  };

package/lib/order/getItemsToPay.js

@@ -0,0 +1,17 @@
+module.exports = () =>
+  function getItemsToPay({ orders, orderItemsToPay }) {
+    return (
+      (Array.isArray(orders) &&
+        orderItemsToPay &&
+        Object.keys(orderItemsToPay).reduce((acc, orderId) => {
+          const orderItemsIds = orderItemsToPay[orderId];
+          const order = orders.find(each => each._id === orderId);
+          if (!order || !orderItemsIds) return acc;
+          const items = order.items.filter(each =>
+            orderItemsIds.includes(each._id)
+          );
+          return acc.concat(items);
+        }, [])) ||
+      []
+    );
+  };

package/lib/order/getMenuItemsByCustomer.js

@@ -0,0 +1,19 @@
+module.exports = ({ modifierActions }) =>
+  function getMenuItemByCustomer({ order, menuItems }) {
+    const { customer } = order || {};
+    if (!customer) return [];
+
+    return menuItems.filter(menuItem => {
+      const { item = {} } = menuItem;
+      const { priceLevels = [] } = item;
+      if (
+        !priceLevels.length &&
+        (modifierActions.hasAllTag(customer) ||
+          modifierActions.hasNoTags(customer))
+      )
+        return true;
+      return priceLevels.some(priceLevel =>
+        modifierActions.hasMatchTags(customer, priceLevel)
+      );
+    });
+  };

package/lib/order/getNumberOfItems.js

@@ -0,0 +1,10 @@
+module.exports = ({ _ }) =>
+  function getNumberOfItems(orders) {
+    if (!orders || !Array.isArray(orders)) return 0;
+    const sum = orders.reduce((acc, order) => {
+      const items = _.get(order, 'items', []);
+      return acc + items.lenght;
+    }, 0);
+
+    return sum;
+  };

package/lib/order/getOrdersPieces.js

@@ -0,0 +1,10 @@
+module.exports = ({ actions, utils }) => {
+  const { math } = utils;
+  return function getOrdersPieces(orders) {
+    if (!Array.isArray(orders)) return 0;
+    return orders.reduce(
+      (acc, order) => math.add(acc, actions.getTotalPieces({ order })),
+      0
+    );
+  };
+};

package/lib/order/getPendingItemIndex.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function getPendingItemIndex(order) {
+    if (!order || !order.items || !order.items.length) return -1;
+    return order.items.findIndex(each => each.isPending);
+  };

package/lib/order/getRelatedItems.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function getRelatedItems({ order, item, compareId = true }) {
+    if (!order || !order.items || !item) return [];
+    return order.items
+      .filter(each => each.properties && each.properties.relatedItem)
+      .filter(
+        each =>
+          each.properties.parentItemId === item.itemId &&
+          (compareId ? each.properties.parentId === item._id : true)
+      );
+  };

package/lib/order/getSameItems.js

@@ -0,0 +1,19 @@
+module.exports = () =>
+  function getSameItems({ order, item }) {
+    const { items = [] } = order;
+    return items.filter(each => {
+      let check =
+        each.itemId &&
+        item._id &&
+        each.itemId === item._id &&
+        !each.serial &&
+        !item.serial;
+      if (check && each.menuId && item.menuId) {
+        check =
+          each.menuId === item.menuId &&
+          each.path.toString() === item.path.toString();
+      }
+
+      return check;
+    });
+  };

package/lib/order/getScheduleByCustomer.js

@@ -0,0 +1,20 @@
+module.exports = ({ _, settings }) => {
+  const orderSettings = _.get(settings, 'order');
+
+  return function getScheduleByCustomer(customer = {}) {
+    const { tags } = customer;
+    const { default: defaultSchedule, ...schedules } =
+      orderSettings.endDate || {};
+    if (!tags || !tags.length) return defaultSchedule;
+
+    const scheduleTags = Object.keys(schedules);
+    if (!scheduleTags || !scheduleTags.length) return defaultSchedule;
+
+    const tag = tags
+      .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/getScreenCustomerNotes.js

@@ -0,0 +1,12 @@
+module.exports = ({ actions }) =>
+  function getScreenCustomerNotes(customer) {
+    let theCustomer = customer;
+    if (!theCustomer) theCustomer = actions.getCustomer();
+    if (!theCustomer) return [];
+    const { notes = [] } = theCustomer;
+    const screenNotes = notes.filter(
+      each => each.message && each.attributes.includes('screen')
+    );
+    if (!screenNotes.length) return [];
+    return screenNotes.map(each => each.message);
+  };

package/lib/order/getSelectedItem.js

@@ -0,0 +1,6 @@
+module.exports = () =>
+  function getSelectedItem({ order, itemIndex }) {
+    if (!order || !order.items || itemIndex < 0) return null;
+    const item = order.items[itemIndex];
+    return item;
+  };

package/lib/order/getStartDate.js

@@ -0,0 +1,4 @@
+module.exports = ({ _ }) =>
+  function getStartDate({ order }) {
+    return _.get(order, 'start.actualDate', '');
+  };

package/lib/order/getTip.js

@@ -0,0 +1,10 @@
+module.exports = ({ modifierActions, utils }) => {
+  const { math } = utils;
+  return function getTip(order) {
+    if (!order || !Array.isArray(order.modifiers)) return 0;
+
+    return order.modifiers
+      .filter(each => modifierActions.isGratuity(each))
+      .reduce((total, modifier) => math.sum(total, modifier.number || 0), 0);
+  };
+};

package/lib/order/getTotalPieces.js

@@ -0,0 +1,17 @@
+module.exports = ({ itemActions, utils }) => {
+  const { math } = utils;
+  return function getTotalPieces({ order, subOrders }) {
+    if (!order) return 0;
+    if (order.items && order.items.length)
+      return itemActions.getItemsTotalPieces(order.items);
+    if (order.isParent && subOrders && subOrders.length)
+      return subOrders.reduce(
+        (acc, each) =>
+          math.add(acc, itemActions.getItemsTotalPieces(each.items)),
+        0
+      );
+    if (order.properties && order.properties.pieceCount)
+      return order.properties.pieceCount;
+    return 0;
+  };
+};

package/lib/order/getTotals.js

@@ -0,0 +1,28 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+  return function getTotals(orders) {
+    if (!Array.isArray(orders)) return { total: 0, subTotals: {} };
+    return orders
+      .filter(each => !!each.parentId || !each.isParent)
+      .reduce(
+        (acc, order) => {
+          const subTotals = {};
+          const { subTotals: orderSubTotals } = order;
+          if (orderSubTotals) {
+            const keys = Object.keys(orderSubTotals);
+            // eslint-disable-next-line no-restricted-syntax
+            for (const key of keys)
+              subTotals[key] = math.add(
+                acc.subTotals[key] || 0,
+                orderSubTotals[key]
+              );
+          }
+          return {
+            total: math.add(acc.total, order.total),
+            subTotals,
+          };
+        },
+        { total: 0, subTotals: {} }
+      );
+  };
+};

package/lib/order/hasAggregate.js

@@ -0,0 +1,20 @@
+module.exports = ({ _, settings, actions, itemActions }) => {
+  const orderSettings = _.get(settings, 'order');
+
+  return function hasAggregate({ order, item }) {
+    if (!order || !item) return false;
+    if (!orderSettings.aggregateItems || itemActions.isRelatedItem(item))
+      return false;
+
+    // if it has a relatedItem, don't aggregate
+    const relatedItems = actions.getRelatedItems({
+      order,
+      item,
+      compareId: false,
+    });
+    if (relatedItems.length) return false;
+
+    const sameItems = actions.getSameItems({ item, order });
+    return !!sameItems.length;
+  };
+};

package/lib/order/hasItem.js

@@ -0,0 +1,7 @@
+module.exports = () =>
+  function hasItem({ order, item }) {
+    if (!order || !item) return -1;
+    const { items = [] } = order;
+
+    return !!items.find(each => each.itemId === item._id);
+  };

package/lib/order/hasRemainingSubscription.js

@@ -0,0 +1,67 @@
+module.exports = ({ actions, modifierActions }) => {
+  const getRemaining = (subscriptions, orderId) => {
+    const remaining = subscriptions.reduce((total, subscription) => {
+      const {
+        numberOfUsesLimit = 0,
+        numberOfUses = 0,
+        history = {},
+      } = subscription;
+      const orderHistory = history[orderId] || 0;
+      return total + numberOfUsesLimit + orderHistory - numberOfUses;
+    }, 0);
+
+    return remaining;
+  };
+
+  const getNumberOfUses = (items = [], item = {}) => {
+    const siblings = items.filter(
+      each =>
+        each.serial === item.serial &&
+        each.itemId === item.itemId &&
+        each._id !== item._id
+    );
+    const modifiers = siblings.reduce(
+      (cur, each) => [
+        ...cur,
+        ...modifierActions.getSubscriptionModifiers(each.modifiers),
+      ],
+      []
+    );
+    const numberOfUses = modifiers.reduce(
+      (sum, each) =>
+        sum +
+        ((each.properties &&
+          each.properties.subscription &&
+          each.properties.subscription.numberOfUses) ||
+          0),
+      0
+    );
+    return numberOfUses;
+  };
+
+  const getSubscriptions = subscriptions =>
+    subscriptions
+      .map(each => modifierActions.getSubscriptionItem(each))
+      .filter(Boolean);
+
+  return function hasRemainingSubscription({ order, item }) {
+    if (!order || !item || !item.itemId) return [false];
+
+    let subscriptions = actions.getCustomerSubscriptionsByItem({
+      customer: order.customer,
+      item,
+    });
+
+    if (!subscriptions || !subscriptions.length) return [false];
+
+    subscriptions = getSubscriptions(subscriptions);
+
+    const isUnlimited = subscriptions.some(each => !each.numberOfUsesLimit);
+    if (isUnlimited) return [true];
+
+    const remaining = getRemaining(subscriptions, order.parentId || order._id);
+    const numberOfUses = getNumberOfUses(order.items, item);
+
+    return [remaining > numberOfUses, remaining, numberOfUses];
+  };
+};

package/lib/order/hold.js

@@ -0,0 +1,12 @@
+module.exports = ({ constants }) =>
+  function holdOrder(order) {
+    if (!order) return order;
+    return {
+      ...order,
+      status: {
+        ...(order.status || {}),
+        order: constants.Status.Order.HOLD,
+      },
+      //   properties: { kitchenOrder: Date.now() },
+    };
+  };

package/lib/order/index.js

@@ -1,6 +1,166 @@
-const { filterExports } = require('../utils');
-const actions = require('./actions');
+//
+const getTotalPieces = require('./getTotalPieces');
+const getStartDate = require('./getStartDate');
+const getBalance = require('./getBalance');
+const getEndDate = require('./getEndDate');
+const isNew = require('./isNew');
+const getSelectedItem = require('./getSelectedItem');
+const updateItem = require('./updateItem');
+const removeItemByIndex = require('./removeItemByIndex');
+const addItem = require('./addItem');
+const duplicateItem = require('./duplicateItem');
+const getCustomer = require('./getCustomer');
+const setCustomer = require('./setCustomer');
+const create = require('./create');
+const updateItemQuantity = require('./updateItemQuantity');
+const getMenuItemsByCustomer = require('./getMenuItemsByCustomer');
+const getPendingItemIndex = require('./getPendingItemIndex');
+const getScreenCustomerNotes = require('./getScreenCustomerNotes');
+const removeItem = require('./removeItem');
+const getSameItems = require('./getSameItems');
+const hasAggregate = require('./hasAggregate');
+const findItemIndex = require('./findItemIndex');
+const changeLocation = require('./changeLocation');
+const addNote = require('./addNote');
+const addTable = require('./addTable');
+const changeEndDate = require('./changeEndDate');
+const changeStartDate = require('./changeStartDate');
+const containsSerial = require('./containsSerial');
+const combineSubOrders = require('./combineSubOrders');
+const calculate = require('./calculate');
+const isParent = require('./isParent');
+const canSplit = require('./canSplit');
+const removeModifier = require('./removeModifier');
+const removeDiscountModifier = require('./removeDiscountModifier');
+const addModifier = require('./addModifier');
+const addDiscountModifier = require('./addDiscountModifier');
+const calculateDue = require('./calculateDue');
+const toggleModifier = require('./toggleModifier');
+const voidOrder = require('./void');
+const holdOrder = require('./hold');
+const openOrder = require('./open');
+const isDetailed = require('./isDetailed');
+const splitByDepartments = require('./splitByDepartments');
+const createParent = require('./createParent');
+const getOrdersPieces = require('./getOrdersPieces');
+const getTotals = require('./getTotals');
+const getDepartmentModifiers = require('./getDepartmentModifiers');
+const getCustomerStoreCredit = require('./getCustomerStoreCredit');
+const getTip = require('./getTip');
+const merge = require('./merge');
+const calculateOrdersDue = require('./calculateOrdersDue');
+const removeModifierByAttribute = require('./removeModifierByAttribute');
+const removeApplyModifier = require('./removeApplyModifier');
+const getCustomerSubscriptions = require('./getCustomerSubscriptions');
+const getCustomerSubscriptionsByItem = require('./getCustomerSubscriptionsByItem');
+const hasRemainingSubscription = require('./hasRemainingSubscription');
+const removeModifiersWithPaymentMethods = require('./removeModifiersWithPaymentMethods');
+const removeModifiersWithPaymentTypes = require('./removeModifiersWithPaymentTypes');
+const getItemsToPay = require('./getItemsToPay');
+const hasItem = require('./hasItem');
+const getNumberOfItems = require('./getNumberOfItems');
+const isOpen = require('./isOpen');
+const isHold = require('./isHold');
+const addItemModifier = require('./addItemModifier');
+const removeItemModifier = require('./removeItemModifier');
+const addModifierToAllItems = require('./addModifierToAllItems');
+const getItemIndex = require('./getItemIndex');
+const getRelatedItems = require('./getRelatedItems');
+const getItemByItemId = require('./getItemByItemId');
+const getScheduleByCustomer = require('./getScheduleByCustomer');
+const pickEndDate = require('./pickEndDate');
+const getAppliedCredit = require('./getAppliedCredit');
+const addCreditModifier = require('./addCreditModifier');
 
-module.exports = {
-  actions: filterExports(actions),
+const orderActions = (deps = {}) => {
+  const actions = {};
+
+  const innerDeps = {
+    ...deps,
+    actions,
+  };
+
+  const freezedActions = Object.freeze({
+    getItemByItemId: getItemByItemId(innerDeps),
+    getTotalPieces: getTotalPieces(innerDeps),
+    getStartDate: getStartDate(innerDeps),
+    getEndDate: getEndDate(innerDeps),
+    isNew: isNew(innerDeps),
+    getSelectedItem: getSelectedItem(innerDeps),
+    updateItem: updateItem(innerDeps),
+    removeItemByIndex: removeItemByIndex(innerDeps),
+    addItem: addItem(innerDeps),
+    duplicateItem: duplicateItem(innerDeps),
+    getCustomer: getCustomer(innerDeps),
+    setCustomer: setCustomer(innerDeps),
+    create: create(innerDeps),
+    updateItemQuantity: updateItemQuantity(innerDeps),
+    getMenuItemsByCustomer: getMenuItemsByCustomer(innerDeps),
+    getPendingItemIndex: getPendingItemIndex(innerDeps),
+    getScreenCustomerNotes: getScreenCustomerNotes(innerDeps),
+    removeItem: removeItem(innerDeps),
+    getSameItems: getSameItems(innerDeps),
+    hasAggregate: hasAggregate(innerDeps),
+    findItemIndex: findItemIndex(innerDeps),
+    changeLocation: changeLocation(innerDeps),
+    addNote: addNote(innerDeps),
+    addTable: addTable(innerDeps),
+    changeEndDate: changeEndDate(innerDeps),
+    changeStartDate: changeStartDate(innerDeps),
+    containsSerial: containsSerial(innerDeps),
+    combineSubOrders: combineSubOrders(innerDeps),
+    calculate: calculate(innerDeps),
+    isParent: isParent(innerDeps),
+    canSplit: canSplit(innerDeps),
+    removeModifier: removeModifier(innerDeps),
+    removeDiscountModifier: removeDiscountModifier(innerDeps),
+    addModifier: addModifier(innerDeps),
+    addDiscountModifier: addDiscountModifier(innerDeps),
+    calculateDue: calculateDue(innerDeps),
+    toggleModifier: toggleModifier(innerDeps),
+    voidOrder: voidOrder(innerDeps),
+    holdOrder: holdOrder(innerDeps),
+    openOrder: openOrder(innerDeps),
+    isDetailed: isDetailed(innerDeps),
+    splitByDepartments: splitByDepartments(innerDeps),
+    createParent: createParent(innerDeps),
+    getOrdersPieces: getOrdersPieces(innerDeps),
+    getTotals: getTotals(innerDeps),
+    getBalance: getBalance(innerDeps),
+    getDepartmentModifiers: getDepartmentModifiers(innerDeps),
+    getCustomerStoreCredit: getCustomerStoreCredit(innerDeps),
+    getTip: getTip(innerDeps),
+    merge: merge(innerDeps),
+    calculateOrdersDue: calculateOrdersDue(innerDeps),
+    removeModifierByAttribute: removeModifierByAttribute(innerDeps),
+    removeApplyModifier: removeApplyModifier(innerDeps),
+    getCustomerSubscriptions: getCustomerSubscriptions(innerDeps),
+    getCustomerSubscriptionsByItem: getCustomerSubscriptionsByItem(innerDeps),
+    hasRemainingSubscription: hasRemainingSubscription(innerDeps),
+    removeModifiersWithPaymentMethods:
+      removeModifiersWithPaymentMethods(innerDeps),
+    removeModifiersWithPaymentTypes: removeModifiersWithPaymentTypes(innerDeps),
+    hasItem: hasItem(innerDeps),
+    getNumberOfItems: getNumberOfItems(innerDeps),
+    isOpen: isOpen(innerDeps),
+    isHold: isHold(innerDeps),
+    getItemsToPay: getItemsToPay(innerDeps),
+    addItemModifier: addItemModifier(innerDeps),
+    removeItemModifier: removeItemModifier(innerDeps),
+    addModifierToAllItems: addModifierToAllItems(innerDeps),
+    getItemIndex: getItemIndex(innerDeps),
+    getRelatedItems: getRelatedItems(innerDeps),
+    getScheduleByCustomer: getScheduleByCustomer(innerDeps),
+    pickEndDate: pickEndDate(innerDeps),
+    getAppliedCredit: getAppliedCredit(innerDeps),
+    addCreditModifier: addCreditModifier(innerDeps),
+  });
+
+  Object.keys(freezedActions).forEach(actionName => {
+    actions[actionName] = freezedActions[actionName];
+  });
+
+  return freezedActions;
 };
+
+module.exports = orderActions;

package/lib/order/isDetailed.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isDetailed(order) {
+    return !!(order && Array.isArray(order.items) && order.items.length);
+  };

package/lib/order/isHold.js

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

package/lib/order/isNew.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isNew(order) {
+    return !!(order && order.isOrderNew);
+  };

package/lib/order/isOpen.js

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

package/lib/order/isParent.js

@@ -0,0 +1,7 @@
+module.exports = () =>
+  function isParent(order) {
+    return !!(
+      order &&
+      ((order.items && order.items.length === 0) || order.isParent)
+    );
+  };

package/lib/order/merge.js

@@ -0,0 +1,96 @@
+module.exports = ({ _, actions, utils }) => {
+  const { math } = utils;
+
+  const isAggregatableItems = (first, second) => {
+    if (
+      first.itemId !== second.itemId ||
+      first.price !== second.price ||
+      first.description !== second.description ||
+      (first.modifiers && !second.modifiers) ||
+      (!first.modifiers && second.modifiers) ||
+      first.modifiers.length !== second.modifiers.length
+    ) {
+      return false;
+    }
+    let hasInvalidModifier = false;
+    first.modifiers.forEach(modifier => {
+      if (!second.modifiers.find(mod => mod._id === modifier._id)) {
+        hasInvalidModifier = true;
+      }
+    });
+
+    return !hasInvalidModifier;
+  };
+
+  // return: [Order, Order, Array<Order>]
+  return function merge({ orders, subOrdersToMerge, aggregateItems, user }) {
+    const items = orders.reduce((res, order) => res.concat(order.items), []);
+    let newOrder = null;
+    // Unique Orders
+    const mOrders = _.uniqBy(orders, '_id');
+    if (aggregateItems) {
+      const newItems = [];
+      items.forEach(item => {
+        const repeatedItem = newItems.find(each =>
+          isAggregatableItems(each, item)
+        );
+        if (repeatedItem) {
+          repeatedItem.quantity = math.add(
+            repeatedItem.quantity,
+            item.quantity
+          );
+        } else {
+          newItems.push({ ...item });
+        }
+      });
+      newOrder = {
+        ...mOrders[0],
+        items: newItems,
+      };
+    } else {
+      newOrder = {
+        ...mOrders[0],
+        items,
+      };
+    }
+
+    newOrder = actions.calculate(newOrder);
+    newOrder = actions.addNote({
+      order: newOrder,
+      message: `This order was merged with ${
+        mOrders.length === 2 ? ` order ` : ` orders `
+      } # ${mOrders.slice(1).map(order => ` ${order.displayId}`)}`,
+      user,
+    });
+
+    const ordersToDelete = [];
+    const voidedOrders = [];
+    for (let i = 1; i < mOrders.length; i += 1) {
+      if (mOrders[i] && mOrders[i].parentId) {
+        ordersToDelete.push(mOrders[i]);
+      } else {
+        let voidedOrder = actions.voidOrder(mOrders[i]);
+        if (!voidedOrder) return null;
+        voidedOrder.isParent = false;
+        voidedOrder = actions.addNote({
+          order: voidedOrder,
+          message: `This order was merged into order #${mOrders[i].displayId}`,
+          user,
+        });
+        voidedOrders.push(voidedOrder);
+      }
+    }
+
+    let subOrders = [];
+    if (newOrder && subOrdersToMerge && subOrdersToMerge.length > 0) {
+      subOrders = subOrdersToMerge.map((s, index) => ({
+        ...s,
+        displayId: `${newOrder.displayId || ''}-${index + 1}`,
+        parentId: newOrder._id,
+        customer: newOrder.customer,
+      }));
+    }
+
+    return [newOrder, voidedOrders, ordersToDelete, subOrders];
+  };
+};

package/lib/order/open.js

@@ -0,0 +1,11 @@
+module.exports = ({ constants }) =>
+  function openOrder(order) {
+    if (!order) return order;
+    return {
+      ...order,
+      status: {
+        ...(order.status || {}),
+        order: constants.Status.Order.OPEN,
+      },
+    };
+  };