@darkpos/pricing 1.0.3 → 1.0.6

package/lib/item/removeModifier.js

@@ -0,0 +1,84 @@
+module.exports = ({ modifierActions, _, actions }) => {
+  const hasRelatedItems = (modifiers = []) =>
+    !!modifiers.find(each => modifierActions.isGroupOfItems(each));
+
+  const isValid = (itemModifiers, modifier) => {
+    if (!modifierActions.findById(itemModifiers, modifier.modifierId))
+      return false;
+
+    if (
+      modifierActions.isRequired(modifier) &&
+      !modifierActions.isGroupOfValues(modifier) &&
+      !modifierActions.isRequiredAndOverride(modifier)
+    )
+      return false;
+
+    if (
+      !modifierActions.isGroupOfItems(modifier) &&
+      hasRelatedItems(itemModifiers)
+    )
+      return false;
+
+    return true;
+  };
+
+  return function removeModifier({
+    item,
+    modifier,
+    customer,
+    cache = {
+      items: [],
+    },
+  }) {
+    const nextItem = _.cloneDeep(item);
+    const itemModifiers = item.modifiers || [];
+    let modifiersToApply = [];
+
+    if (!isValid(itemModifiers, modifier)) return item;
+
+    // Check for multiple and add them to menuModifiers
+    if (modifierActions.hasAddModifiers(modifier)) {
+      const relatedModifiers = modifierActions.getRelatedModifiers(modifier);
+      // Removing only those children who are selected
+      const currentModifiersIds = itemModifiers.map(each => each.modifierId);
+      modifiersToApply = relatedModifiers.filter(each =>
+        currentModifiersIds.includes(each._id)
+      );
+    }
+
+    modifiersToApply.push(modifier);
+    // Remove
+    const nextModifiers = item.modifiers.filter(
+      each =>
+        !modifiersToApply.find(
+          mod =>
+            each.modifierId === mod._id ||
+            each._id === mod._id ||
+            each.modifierId === mod.modifierId
+        )
+    );
+
+    const hasOverride = modifiersToApply.find(each =>
+      modifierActions.isOverride(each)
+    );
+
+    if (hasOverride) {
+      const originalItem =
+        cache.items.find(_item => _item._id === item.itemId) || item;
+
+      if (modifierActions.isQuantityOverride(modifier)) nextItem.quantity = 1;
+
+      if (modifierActions.isPriceOverride(modifier))
+        nextItem.price = actions.getItemPrice({
+          item: originalItem,
+          cache,
+          customer,
+        });
+    }
+
+    return {
+      ...nextItem,
+      modifiers: nextModifiers,
+    };
+  };
+};

package/lib/item/removeModifierById.js

@@ -0,0 +1,8 @@
+module.exports = () =>
+  function removeModifierById({ item, modifierId }) {
+    if (!item || !modifierId) return item;
+    return {
+      ...item,
+      modifiers: item.modifiers.filter(modifier => modifier._id !== modifierId),
+    };
+  };

package/lib/item/removeModifiers.js

@@ -0,0 +1,14 @@
+module.exports = ({ actions }) =>
+  function removeModifiers({ item, modifiers, cache, customer }) {
+    const newItem = modifiers.reduce(
+      (nextItem, modifier) =>
+        actions.removeModifier({
+          item: nextItem,
+          modifier,
+          cache,
+          customer,
+        }),
+      item
+    );
+    return newItem;
+  };

package/lib/order/addCreditModifier.js

@@ -0,0 +1,27 @@
+module.exports = ({ modifierActions, _ }) => {
+  const getCreditModifierIndex = modifiers => {
+    if (!modifiers) return -1;
+    return modifiers.findIndex(each => modifierActions.isCredit(each));
+  };
+  //
+  return function addCreditModifier({ order, customerStoredCredit }) {
+    if (!order || !customerStoredCredit) return order;
+    const nextOrder = _.cloneDeep(order);
+    const { modifiers = [] } = nextOrder;
+    let creditModifier;
+    const index = getCreditModifierIndex(modifiers);
+    if (index > -1) {
+      creditModifier = modifiers[index];
+      modifiers.splice(index, 1);
+    }
+    creditModifier = modifierActions.createCreditModifier({
+      ...creditModifier,
+      customerStoredCredit,
+    });
+    modifiers.push(creditModifier);
+    return {
+      ...nextOrder,
+      modifiers,
+    };
+  };
+};

package/lib/order/addDiscountModifier.js

@@ -0,0 +1,9 @@
+module.exports = ({ actions }) =>
+  function addDiscountModifier({ order, modifier }) {
+    if (!order || !modifier) return order;
+    const clearedOrder = actions.removeDiscountModifier(order);
+    return actions.addModifier({
+      order: clearedOrder,
+      modifier,
+    });
+  };

package/lib/order/addItem.js

@@ -0,0 +1,292 @@
+module.exports = ({
+  actions,
+  itemActions,
+  modifierActions,
+  utils,
+  settings,
+  _,
+}) => {
+  const { math } = utils;
+  const orderSettings = _.get(settings, 'order');
+
+  const getQuantity = ({ order, item, pendingItemIndex = -1 }) => {
+    let pendingItemQty = 0;
+    if (pendingItemIndex > -1) {
+      pendingItemQty = order.items[pendingItemIndex].quantity;
+    }
+    return pendingItemQty || item.quantity || 1;
+  };
+
+  const getItem = ({ order, item, pendingItemIndex }) => {
+    const { items = [] } = order;
+    const hasAggregation = actions.hasAggregate({ order, item });
+
+    if (hasAggregation) {
+      const aggregateItems = actions.getSameItems({ order, item });
+      const idx = items.findIndex(each =>
+        aggregateItems.find(aItem => aItem.itemId === each.itemId)
+      );
+
+      const aggregateItem = items[idx];
+      aggregateItem.quantity += getQuantity({ order, item, pendingItemIndex });
+      return [aggregateItem, idx, hasAggregation];
+    }
+
+    const newItem = itemActions.create({
+      ...item,
+      modifiers: [],
+      quantity: item.quantity || 1,
+      itemId: item.itemId,
+      pieces: itemActions.isRelatedItem(item) ? 0 : item.pieces,
+    });
+
+    return [newItem];
+  };
+
+  const getInventory = item => {
+    const { inventory } = item;
+
+    if (!inventory) return null;
+
+    return {
+      ...inventory,
+      name: item.name,
+      isNew: true,
+    };
+  };
+
+  const getSubscription = ({ order, item, combined, cache }) => {
+    const [hasSubscription, remaining, used] = actions.hasRemainingSubscription(
+      {
+        order,
+        item,
+        combined,
+      }
+    );
+    let orderItem = item;
+
+    if (!hasSubscription) return orderItem;
+
+    const subscriptionModifiers = modifierActions.getSubscriptionModifiers(
+      orderItem.modifiers
+    );
+    if (!_.isEmpty(subscriptionModifiers)) {
+      orderItem = itemActions.removeModifiers({
+        item: orderItem,
+        modifiers: subscriptionModifiers,
+        cache,
+        customer: order.customer,
+      });
+    }
+
+    const { quantity, price } = orderItem;
+    let numberOfUses = quantity;
+    if (remaining) {
+      const left = remaining - (used || 0);
+      if (quantity > left) numberOfUses = left;
+    }
+
+    const modifier = modifierActions.createSubscriptionModifier({
+      amount: math.mul(numberOfUses, price),
+      properties: { subscription: { numberOfUses } },
+    });
+    orderItem.modifiers.push(modifier);
+
+    return orderItem;
+  };
+
+  const addOrderItem = ({ itemIndex, order, item }) => {
+    if (itemIndex > -1) {
+      const updatedOrder = actions.updateItem({
+        order,
+        itemIndex,
+        item,
+      });
+
+      return [updatedOrder, itemIndex, item];
+    }
+
+    let { items = [] } = order;
+    if (orderSettings.orderAddToTop) items = [item, ...items];
+    else items.push(item);
+
+    const updatedOrder = { ...order, items };
+    return [
+      updatedOrder,
+      orderSettings.orderAddToTop ? 0 : items.length - 1,
+      item,
+    ];
+  };
+
+  const reArrangeNewItem = ({ nextOrder, nextItemIndex }) => {
+    const reArrangedOrder = { ...nextOrder };
+    const shouldMoveToTop = orderSettings.orderAddToTop && nextItemIndex > 0;
+    const shouldMoveToBottom =
+      !orderSettings.orderAddToTop &&
+      nextItemIndex < reArrangedOrder.items.length - 1;
+
+    if (shouldMoveToTop || shouldMoveToBottom) {
+      if (shouldMoveToTop) {
+        const [itemToMove] = reArrangedOrder.items.splice(nextItemIndex, 1);
+        reArrangedOrder.items.unshift(itemToMove);
+        return { reArrangedOrder, newIndex: 0 };
+      }
+      const [itemToMove] = reArrangedOrder.items.splice(nextItemIndex, 1);
+      reArrangedOrder.items.push(itemToMove);
+      return {
+        reArrangedOrder,
+        newIndex: reArrangedOrder.items.length - 1,
+      };
+    }
+
+    // Nothing should be rearranged
+    return {};
+  };
+
+  const getUnselectedModifiers = (item, modifiers) => {
+    const ids = item.modifiers.map(each => each.modifierId).filter(Boolean);
+    return modifiers.filter(
+      each => !ids.includes(each.modifierId) && !ids.includes(each._id)
+    );
+  };
+
+  return function addItem({
+    order: orderProp,
+    item,
+    itemIndex,
+    cache,
+    overridenQuantity,
+  }) {
+    if (!orderProp || !item) return orderProp;
+
+    let order = _.cloneDeep(orderProp);
+    const { itemModifiers, ...itemToAdd } = item;
+    const customer = actions.getCustomer(order);
+    const modifiersToAdd = [];
+
+    const pendingItemIndex = actions.getPendingItemIndex(order);
+
+    let [orderItem, idx, combined] = getItem({
+      item: itemToAdd,
+      order,
+      pendingItemIndex,
+    });
+
+    // Default modifiers
+    if (idx === undefined && !_.isEmpty(item.modifiers))
+      modifiersToAdd.push(
+        ...item.modifiers.map(each => modifierActions.create(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);
+        }
+      }
+    }
+
+    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 });
+        }
+      }
+    }
+
+    // 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);
+
+    orderItem = getSubscription({
+      order,
+      item: orderItem,
+      combined,
+      cache,
+    });
+
+    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
+      );
+    }
+
+    const { reArrangedOrder, newIndex } = reArrangeNewItem({
+      nextOrder,
+      nextItemIndex,
+    });
+
+    if (reArrangedOrder && newIndex) {
+      nextOrder = { ...reArrangedOrder };
+      nextItemIndex = newIndex;
+    }
+
+    // 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);
+    }
+
+    return [nextOrder, nextItemIndex, nextItem];
+  };
+};

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;
+  };
+};