@darkpos/pricing 1.0.5 → 1.0.6

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,8 +1,169 @@
-const makeCalculate = require('./calculate');
+const constants = require('../constants');
+//
+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 = (deps = {}) => {
-  //
-  return Object.freeze({
-    calculate: makeCalculate(deps),
+const orderActions = (deps = {}) => {
+  const actions = {};
+
+  const innerDeps = {
+    ...deps,
+    constants,
+    actions,
+  };
+
+  const freezedActions = Object.freeze({
+    constants,
+    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,
+      },
+    };
+  };

package/lib/order/pickEndDate.js

@@ -0,0 +1,70 @@
+module.exports = ({ settings, _, moment }) => {
+  const timezone = _.get(settings, 'localization.timezone', 'America/New_York');
+  const isInSchedule = (each, date) => {
+    const isoWeekday = moment(date).tz(timezone).isoWeekday();
+    let check = false;
+    if (each.day !== undefined && each.day !== null)
+      check = String(each.day) === String(isoWeekday === 7 ? 0 : isoWeekday);
+
+    if (each.date)
+      check =
+        moment(date).startOf('day').tz(timezone).format('YYYYMMDD') ===
+        moment(each.date).startOf('day').tz(timezone).format('YYYYMMDD');
+    return check;
+  };
+
+  const checkStoreSchedule = date => {
+    const schedule = _.get(settings, 'schedule', {});
+    const { close = [] } = schedule;
+
+    if (close.length) return !close.find(each => isInSchedule(each, date));
+
+    return true;
+  };
+  return function pickEndDate(schedule = {}, skip = 0, date = undefined) {
+    const {
+      addDays = 1,
+      hour,
+      minute,
+      skipDays = [],
+      cutHour,
+      cutDay = 1,
+    } = schedule;
+    let days = skip || Number(addDays);
+
+    const todayTimezone = moment().tz(timezone);
+    const dateTimezone = date || todayTimezone;
+
+    if (
+      !skip &&
+      !date &&
+      cutHour &&
+      todayTimezone.isAfter(moment(schedule.cutHour, 'hh:mm:ss').tz(timezone))
+    ) {
+      console.log('cut day applied');
+      days += cutDay;
+    }
+
+    const endDate = dateTimezone.add(Number(days), 'days');
+    console.log('check date => ', endDate.format());
+
+    const isoWeekday = endDate.isoWeekday();
+    console.log('isoWeekday => ', isoWeekday);
+
+    if (skipDays && skipDays.includes(isoWeekday === 7 ? 0 : isoWeekday)) {
+      console.log('check next day: in Skip days');
+      return pickEndDate(schedule, 1, endDate);
+    }
+    if (!checkStoreSchedule(endDate)) {
+      console.log('check next day: in Close days');
+      return pickEndDate(schedule, 1, endDate);
+    }
+
+    if (hour !== undefined) endDate.set('hour', hour);
+    if (minute !== undefined) endDate.set('minute', minute);
+    endDate.set('second', 0);
+
+    console.log('final date in local', endDate.format());
+    return moment.utc(endDate).format();
+  };
+};

package/lib/order/removeApplyModifier.js

@@ -0,0 +1,24 @@
+module.exports = ({ actions }) =>
+  function removeApplyModifier({
+    order,
+    attribute,
+    modifier,
+    applyItems = true,
+  }) {
+    if (!order) return order;
+    let newOrder = { ...order };
+
+    if (attribute) {
+      newOrder = actions.removeModifierByAttribute({
+        order,
+        attribute,
+        applyItems,
+      });
+    }
+
+    if (modifier) {
+      newOrder = actions.addModifier({ order: newOrder, modifier });
+    }
+
+    return newOrder;
+  };

package/lib/order/removeDiscountModifier.js

@@ -0,0 +1,16 @@
+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 };
+  };

package/lib/order/removeItem.js

@@ -0,0 +1,56 @@
+module.exports = ({ actions, _, itemActions }) => {
+  const updateRelatedItems = (items, parentId) => {
+    return 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;
+
+    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);
+
+    if (!hard || hasRelatedItem) {
+      items[orderItemIdx] = { ...orderItem, price: 0, modifiers: [] };
+      if (hasRelatedItem) {
+        items = updateRelatedItems(items, item._id);
+        // console.log('Update related items ...', items);
+      }
+    }
+    // Decrease the quantity
+    else 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 });
+      // console.log('Removing parent item ...');
+      if (siblings <= 1) items.splice(parentIndex, 1);
+    }
+
+    return {
+      ...order,
+      items,
+    };
+  };
+};

package/lib/order/removeItemByIndex.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function removeItemByIndex({ order, itemIndex }) {
+    if (!order || !order.items || itemIndex < 0) return order;
+    return actions.removeItem({ order, item: order.items[itemIndex] });
+  };

package/lib/order/removeItemModifier.js

@@ -0,0 +1,69 @@
+module.exports = ({ actions, modifierActions, itemActions, utils, _ }) => {
+  const { math } = utils;
+
+  const getPrice = ({ item, modifier }) => {
+    const amount =
+      (modifier && modifier.compute && modifier.compute.amount) || 0;
+    const { price = 0 } = item;
+    if (modifierActions.isMultiplier(modifier)) return math.mul(price, amount);
+    return amount;
+  };
+
+  const removeModifier = ({ item, modifier, originalItem }) => {
+    const nextItem = { ...item, modifiers: [] };
+
+    nextItem.modifiers = item.modifiers.filter(
+      each => (each.modifierId || each._id) !== modifier._id
+    );
+
+    if (modifierActions.isAmountOverride(modifier))
+      return {
+        ...originalItem,
+        ...nextItem,
+      };
+
+    if (modifierActions.isPriceOverride(modifier))
+      nextItem.price = getPrice({ modifier, item: nextItem });
+
+    if (modifierActions.isQuantityOverride(modifier)) nextItem.quantity = 1;
+
+    return nextItem;
+  };
+
+  return function removeItemModifier({
+    order: orderProp,
+    modifier,
+    itemIndex,
+    cache,
+  }) {
+    const order = _.cloneDeep(orderProp);
+    if (!order || itemIndex < 0 || !modifier) return order;
+
+    let item = actions.getSelectedItem({ order, itemIndex });
+    const customer = actions.getCustomer(order);
+    const originalItem = cache.items.find(_item => _item._id === item.itemId);
+    const contains = modifierActions.contains(item.modifiers, modifier);
+
+    if (!contains) return order;
+    if (
+      modifierActions.isGroupOfValues(modifier) ||
+      modifierActions.isRequiredAndOverride(modifier)
+    )
+      return order;
+
+    // Remove
+    item = removeModifier({
+      item,
+      modifier,
+      originalItem,
+    });
+    item.price = itemActions.getItemPrice({
+      item,
+      cache,
+      customer,
+    });
+    order.items[itemIndex] = item;
+
+    return order;
+  };
+};