@darkpos/pricing 1.0.3 → 1.0.6

package/lib/order/addTable.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function addTable({ order, table }) {
+    if (!order || !table) return order;
+    const nextOrder = { ...order };
+    const { location = {} } = nextOrder;
+    nextOrder.location = {
+      ...location,
+      table: { _id: table._id, name: table.name },
+    };
+    return nextOrder;
+  };

package/lib/order/calculate.js

@@ -0,0 +1,105 @@
+/* eslint-disable no-restricted-syntax */
+/**
+ * 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) {
+    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);
+    itemsWNIM = itemActions.calculate(itemsWNIM);
+    const newOrder = { ...order, ...pricing(itemsWNIM), items: itemsWNIM };
+
+    if (!modifiers.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) {
+      const isCredit = modifierActions.isCredit(modifier);
+      if (isCredit) {
+        const calculatedItemWIM = itemActions.calculate(itemsWIM);
+        ({ total: computedTotal } = pricing(calculatedItemWIM));
+      }
+      const itemsModifiers = itemActions.addIndirectModifier(
+        computedTotal,
+        newItems,
+        modifier
+      );
+      // adding the modifiers to items
+      itemsWIM = itemsWIM.map(item => ({
+        ...item,
+        modifiers: [...(item.modifiers || []), itemsModifiers[item._id]].filter(
+          Boolean
+        ),
+      }));
+    }
+
+    const calculatedItemWIM = itemActions.calculate(itemsWIM);
+    return {
+      ...order,
+      ...pricing(calculatedItemWIM),
+      items: calculatedItemWIM,
+    };
+  };
+};

package/lib/order/calculateDue.js

@@ -0,0 +1,15 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+  return function calculateDue(order) {
+    if (!order || !Array.isArray(order.items)) return 0;
+    let total = 0;
+    let totalPaid = 0;
+
+    order.items.forEach(item => {
+      total = math.add(total, item.total);
+      totalPaid = math.add(totalPaid, item.totalPaid);
+    });
+
+    return math.sub(total, totalPaid);
+  };
+};

package/lib/order/calculateOrdersDue.js

@@ -0,0 +1,26 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+  return function calculateOrdersDue(orders, orderItemsToPay) {
+    let total = 0;
+    let totalPaid = 0;
+    const isPartial = !!(
+      orderItemsToPay && Object.keys(orderItemsToPay).length > 0
+    );
+
+    orders.forEach(order => {
+      const orderItemIds =
+        (orderItemsToPay && orderItemsToPay[order._id]) || [];
+      order.items.forEach(it => {
+        if (!isPartial) {
+          total += it.total;
+          totalPaid += it.totalPaid;
+        } else if (orderItemIds.includes(it._id)) {
+          total += it.total;
+          totalPaid += it.totalPaid;
+        }
+      });
+    });
+
+    return math.sub(total, totalPaid);
+  };
+};

package/lib/order/canSplit.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function canSplit(order) {
+    return !!(order && !(order.parentId || order.isParent));
+  };

package/lib/order/changeEndDate.js

@@ -0,0 +1,15 @@
+module.exports = ({ utils }) =>
+  function changeEndDate({ date, order }) {
+    if (!date || !order) return order;
+    const nextOrder = { ...order };
+    if (!nextOrder.end) nextOrder.end = { __typename: 'OrderEnd' };
+
+    const isoString = utils.date.toISOString(date);
+    nextOrder.end = {
+      ...nextOrder.end,
+      actualDate: utils.date.isToday(date) ? isoString : '',
+      requestDate: isoString,
+      __typename: 'OrderEnd',
+    };
+    return nextOrder;
+  };

package/lib/order/changeLocation.js

@@ -0,0 +1,20 @@
+module.exports = () =>
+  function changeLocation({ order, location, isStart }) {
+    if (!order || !location) return order;
+    const nextOrder = { ...order };
+    if (isStart) {
+      if (!nextOrder.start) nextOrder.start = { __typename: 'OrderStart' };
+      nextOrder.start = {
+        ...nextOrder.start,
+        location,
+      };
+      return nextOrder;
+    }
+
+    if (!nextOrder.end) nextOrder.end = { __typename: 'OrderEnd' };
+    nextOrder.end = {
+      ...nextOrder.end,
+      location,
+    };
+    return nextOrder;
+  };

package/lib/order/changeStartDate.js

@@ -0,0 +1,14 @@
+module.exports = ({ utils }) =>
+  function changeStartDate({ date, order }) {
+    if (!date || !order) return order;
+    const nextOrder = { ...order };
+    if (!nextOrder.start) nextOrder.start = { __typename: 'OrderStart' };
+
+    const isoString = utils.date.toISOString(date);
+    nextOrder.start = {
+      ...nextOrder.start,
+      actualDate: utils.date.isToday(date) ? isoString : '',
+      requestDate: isoString,
+    };
+    return nextOrder;
+  };

package/lib/order/combineSubOrders.js

@@ -0,0 +1,14 @@
+module.exports = () =>
+  function combineSubOrders({ order, subOrders = [] }) {
+    if (!order || !subOrders || !subOrders.length) return order;
+
+    const items = subOrders.reduce(
+      (arr, each) => arr.concat(each.items || []),
+      []
+    );
+    return {
+      ...order,
+      orders: subOrders,
+      items,
+    };
+  };

package/lib/order/containsSerial.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function containsSerial({ order, serial }) {
+    if (!order || !order.items || !serial) return false;
+    return !!order.items.find(each => each.serial === serial);
+  };

package/lib/order/create.js

@@ -0,0 +1,67 @@
+module.exports = ({ utils, constants = {} }) => {
+  const { helpers } = utils;
+
+  const defaultOrderStatus = {
+    order: constants.status.Order.OPEN,
+    kitchen: constants.status.Kitchen.OPEN,
+    delivery: constants.status.Delivery.NONE,
+    detailed: true,
+  };
+  const orderEnd = {
+    actualDate: '',
+    requestDate: '',
+    location: null,
+    __typename: 'OrderEnd',
+  };
+  const orderStart = {
+    actualDate: utils.date.toISOString(),
+    requestDate: '',
+    location: null,
+    __typename: 'OrderStart',
+  };
+  const defaultOrder = {
+    get _id() {
+      return helpers.getObjectID();
+    },
+    parentId: null,
+    isParent: false,
+    subTotal: 0,
+    tax: 0,
+    modifiers: [],
+    discount: 0,
+    total: 0,
+    description: '',
+    displayId: '',
+    type: '',
+    location: {},
+    status: defaultOrderStatus,
+    attributes: [],
+    properties: {},
+    fee: 0,
+    user: null,
+    items: [],
+    notes: [],
+    customer: null,
+    start: orderStart,
+    end: orderEnd,
+    _storeId: '',
+    __typename: 'Order',
+  };
+
+  return function create(params = {}) {
+    return {
+      ...defaultOrder,
+      ...params,
+    };
+  };
+};
+
+/**
+ TODO: {
+    table: {
+      _id: locationState?.table._id,
+      name: locationState?.table.name,
+    },
+    type: location || LocationTypes.walkIn,
+  }
+* */

package/lib/order/createParent.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function createParent(order) {
+    if (!order) return order;
+    return {
+      ...order,
+      items: [],
+      isParent: true,
+    };
+  };

package/lib/order/duplicateItem.js

@@ -0,0 +1,16 @@
+module.exports = ({ utils }) => {
+  const { helpers } = utils;
+  return function duplicateItem({ order, item }) {
+    if (!order || !order.items) return order;
+
+    const nextOrder = { ...order };
+    const newItem = {
+      ...item,
+      serial: '',
+      _id: helpers.getObjectID(),
+    };
+
+    nextOrder.items.push(newItem);
+    return nextOrder;
+  };
+};

package/lib/order/findItemIndex.js

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

package/lib/order/getAppliedCredit.js

@@ -0,0 +1,5 @@
+module.exports = ({ _ }) =>
+  function getAppliedCredit(order) {
+    if (!order) return 0;
+    return Math.abs(_.get(order, 'subTotals.credit', 0));
+  };

package/lib/order/getBalance.js

@@ -0,0 +1,9 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+  return function getBalance({ order }) {
+    if (!order) return 0;
+    if (Array.isArray(order)) return 0;
+
+    return math.sub(order.total, order.totalPaid);
+  };
+};

package/lib/order/getCustomer.js

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

package/lib/order/getCustomerStoreCredit.js

@@ -0,0 +1,14 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+  return function getCustomerStoreCredit(order) {
+    if (!order || !order.customer || !Array.isArray(order.customer.wallet))
+      return 0;
+    return order.customer.wallet
+      .filter(
+        each =>
+          each && each.provider === 'darkpos' && each.cards && each.cards.length
+      )
+      .reduce((acc, each) => [...acc, ...each.cards], [])
+      .reduce((acc, each) => math.add(acc, each.amount || 0), 0);
+  };
+};

package/lib/order/getCustomerSubscriptions.js

@@ -0,0 +1,8 @@
+module.exports = ({ modifierActions }) =>
+  function getCustomerSubscriptions(customer) {
+    if (!customer || !Array.isArray(customer.modifiers)) return [];
+    const subscriptions = modifierActions.getSubscriptionModifiers(
+      customer.modifiers
+    );
+    return subscriptions;
+  };

package/lib/order/getCustomerSubscriptionsByItem.js

@@ -0,0 +1,14 @@
+module.exports = ({ actions, modifierActions }) =>
+  function getCustomerSubscriptionsByItem({ customer, item }) {
+    if (!customer || !item) return [];
+    const subscriptions = actions.getCustomerSubscriptions(customer);
+    return subscriptions.filter(each => {
+      const subscribedItem = modifierActions.getSubscriptionItem(each);
+
+      return (
+        subscribedItem &&
+        subscribedItem.itemId === item.itemId &&
+        (!subscribedItem.serial || subscribedItem.serial === item.serial)
+      );
+    });
+  };

package/lib/order/getDepartmentModifiers.js

@@ -0,0 +1,9 @@
+module.exports = ({ itemActions }) =>
+  function getDepartmentModifiers(order) {
+    if (!order) return [];
+
+    return order.items.reduce(
+      (acc, item) => [...acc, ...itemActions.getDepartmentModifiers(item)],
+      []
+    );
+  };

package/lib/order/getEndDate.js

@@ -0,0 +1,6 @@
+module.exports = ({ utils }) => {
+  const { _ } = utils;
+  return 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,12 @@
+module.exports = ({ utils }) => {
+  const { _ } = utils;
+  return 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,14 @@
+module.exports = () =>
+  function getSameItems({ order, item }) {
+    const { items = [] } = order;
+    return items.filter(each => {
+      let check = 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: {} }
+      );
+  };
+};