@darkpos/pricing 1.0.4 → 1.0.7

package/lib/order/addItemModifier.js

@@ -0,0 +1,214 @@
+module.exports = ({ actions, itemActions, modifierActions, 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 filterByRemoveModifiers = (modifiers, modifier) => {
+    const { delModifiers = [] } = modifier;
+
+    return modifiers.filter(
+      each => !modifierActions.findById(delModifiers, each.modifierId)
+    );
+  };
+
+  const hasBehaivoralFields = modifier => {
+    if (
+      !modifierActions.hasRelatedItems(modifier) &&
+      modifierActions.isGroupOfItems(modifier)
+    )
+      return true;
+    return false;
+  };
+
+  const validateItemPiecesCondition = (itemPieces, minPieces) => {
+    if (!minPieces) return true;
+    return minPieces <= itemPieces;
+  };
+
+  const validateItemQtyCondition = (itemQuantity, minQuantity) => {
+    if (!minQuantity) return true;
+    return minQuantity <= itemQuantity;
+  };
+
+  const validateRequiredModifiers = (modifiers, requiredModifiers) => {
+    if (_.isEmpty(modifiers) || _.isEmpty(requiredModifiers)) return true;
+    return requiredModifiers.every(each =>
+      modifierActions.contains(modifiers, each)
+    );
+  };
+
+  const areConditionsMet = (item, conditions) => {
+    if (!conditions) return true;
+
+    return (
+      validateItemPiecesCondition(item.pieces, conditions.minItemPieces) &&
+      validateItemQtyCondition(item.quantity, conditions.minItemQuantity) &&
+      validateRequiredModifiers(item.modifiers, conditions.modifiers)
+    );
+  };
+
+  const addModifier = ({
+    modifier,
+    item: itemProp,
+    customer,
+    cache = {
+      modifiers: [],
+      items: [],
+      itemModifiers: [],
+    },
+  }) => {
+    let item = { ...itemProp };
+    if (hasBehaivoralFields(modifier)) return item;
+    // check conditions
+    if (!areConditionsMet(item, modifier.conditions)) return item;
+
+    const modifierToAdd = modifierActions.duplicate(modifier);
+    const modifierIndex = item.modifiers.findIndex(
+      ieach => ieach.modifierId === modifier._id
+    );
+
+    // group of values use case
+    if (
+      modifierActions.isGroupOfValues(modifier) ||
+      modifierActions.isRequiredAndOverride(modifier)
+    ) {
+      if (modifierIndex > -1) item.modifiers[modifierIndex] = modifierToAdd;
+      else item.modifiers.push(modifierToAdd);
+    } else {
+      item.modifiers.push(modifierToAdd);
+    }
+
+    if (modifierActions.isRemoveModifier(modifier)) {
+      item.modifiers = filterByRemoveModifiers(item.modifiers, modifier);
+    }
+
+    if (modifierActions.isAmountOverride(modifier)) {
+      item = {
+        ...item,
+        price: modifier.compute.amount,
+      };
+    }
+
+    if (modifierActions.isQuantityOverride(modifier) && modifier.compute) {
+      item.quantity = modifier.compute.amount || 1;
+    }
+
+    if (modifierActions.isPriceOverride(modifier)) {
+      item.price = getPrice({ modifier, item });
+    } else {
+      item.price = itemActions.getItemPrice({
+        item,
+        cache,
+        customer,
+      });
+    }
+    return item;
+  };
+
+  return function addItemModifier({
+    order: orderProp,
+    modifier,
+    itemIndex,
+    cache,
+  }) {
+    let order = _.cloneDeep(orderProp);
+    if (!order || itemIndex < 0 || !modifier) return order;
+
+    let item = actions.getSelectedItem({ order, itemIndex });
+    const customer = actions.getCustomer(order);
+    const contains =
+      !_.isEmpty(item.modifiers) &&
+      modifierActions.contains(item.modifiers, modifier);
+
+    const usingCount = contains
+      ? modifierActions.getUsingCount(item.modifiers, modifier)
+      : 0;
+
+    // don't add modifier if it is subscription and it doesn't have any other subscription
+    if (
+      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
+    if (
+      contains &&
+      usingCount >= item.quantity &&
+      !(
+        modifierActions.isGroupOfValues(modifier) ||
+        modifierActions.isRequiredAndOverride(modifier)
+      )
+    ) {
+      // console.log('Removing MODIFIER ...');
+      order = actions.removeItemModifier({
+        order,
+        modifier,
+        itemIndex,
+        cache,
+      });
+      return order;
+    }
+
+    item = addModifier({
+      item,
+      modifier,
+      cache,
+      customer,
+    });
+
+    // Recursive Rules:
+    if (modifierActions.hasAddModifiers(modifier)) {
+      let relatedModifiers = modifierActions.getRelatedModifiers({
+        modifier,
+        modifiers: cache.modifiers,
+      });
+      relatedModifiers = relatedModifiers.filter(
+        each => !modifierActions.contains(item.modifiers, each)
+      );
+      item = relatedModifiers.reduce(
+        (acc, each) =>
+          addModifier({
+            item: acc,
+            modifier: each,
+            cache,
+            customer,
+          }),
+        item
+      );
+    }
+
+    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: {
+            ...each,
+            itemId: each._id,
+            _id: null,
+            properties: {
+              relatedItem: true,
+              parentId: item._id,
+              parentItemId: item.itemId,
+              includeParent: true,
+            },
+          },
+          order: acc,
+          cache,
+        });
+        return nextOrder;
+      }, order);
+    }
+
+    return order;
+  };
+};

package/lib/order/addModifier.js

@@ -0,0 +1,9 @@
+module.exports = ({ modifierActions }) =>
+  function addModifier({ order, modifier }) {
+    if (!modifier) return order;
+    const { modifiers = [] } = order;
+    return {
+      ...order,
+      modifiers: [...modifiers, modifierActions.create(modifier)],
+    };
+  };

package/lib/order/addModifierToAllItems.js

@@ -0,0 +1,16 @@
+module.exports = ({ actions }) =>
+  function addModifierToAllItems({ order, modifier, cache }) {
+    if (!order || !Array.isArray(order.items) || !modifier) return order;
+
+    const nextOrder = Object.entries(order.items).reduce(
+      (acc, [itemIndex]) =>
+        actions.addItemModifier({
+          itemIndex,
+          modifier,
+          order: acc,
+          cache,
+        }),
+      order
+    );
+    return nextOrder;
+  };

package/lib/order/addNote.js

@@ -0,0 +1,25 @@
+module.exports = ({ utils }) => {
+  const { date } = utils;
+  const defaults = {
+    message: '',
+    attributes: [],
+    date: date.toISOString(),
+    user: null,
+    url: '',
+    __typename: 'Note',
+  };
+
+  return function addNote({ user, order, message }) {
+    if (!order || !message || !user) return order;
+    const newNote = {
+      ...defaults,
+      user,
+      message,
+    };
+    const nextOrder = {
+      ...order,
+      notes: [...(order.notes || []), newNote],
+    };
+    return nextOrder;
+  };
+};

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)],
+      []
+    );
+  };