@darkpos/pricing 1.0.5 → 1.0.8

package/lib/modifier/isGroupOfModifiers.js

@@ -0,0 +1,12 @@
+module.exports = ({ actions, constants }) => {
+  const { Modifier } = constants;
+  return function isGroupOfModifiers(modifier) {
+    const { properties = {} } = modifier || {};
+    return !!(
+      actions.hasAttribute(modifier, Modifier.Attributes.GROUP) &&
+      properties &&
+      properties.group &&
+      (properties.group.modifiers || []).length
+    );
+  };
+};

package/lib/modifier/isGroupOfValues.js

@@ -0,0 +1,13 @@
+module.exports = ({ actions, constants }) => {
+  const { Modifier } = constants;
+  return function isGroupOfValues(modifier) {
+    const { properties = {} } = modifier || {};
+    return !!(
+      actions.hasAttribute(modifier, Modifier.Attributes.GROUP) &&
+      properties &&
+      properties.group &&
+      ((properties.group.values || []).length ||
+        (properties.group.selectedValues || []).length)
+    );
+  };
+};

package/lib/modifier/isHidden.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isHidden(modifier) {
+    return modifier.hidden;
+  };

package/lib/modifier/isIncluded.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isIncluded(modifier) {
+    return modifier.included;
+  };

package/lib/modifier/isManual.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function isManual(modifier) {
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.override &&
+      modifier.properties.override.type === 'manual'
+    );
+  };

package/lib/modifier/isMultiplier.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function isMultiplier(modifier) {
+    if (!modifier) return false;
+    const _modifier = modifier.modifier || modifier;
+    return !!(
+      _modifier &&
+      _modifier.properties &&
+      _modifier.properties.override &&
+      _modifier.properties.override.multiplier
+    );
+  };

package/lib/modifier/isOverride.js

@@ -0,0 +1,6 @@
+module.exports = ({ actions, constants }) => {
+  const { Modifier } = constants;
+  return function isOverride(modifier) {
+    return actions.hasAttribute(modifier, Modifier.Attributes.OVERRIDE);
+  };
+};

package/lib/modifier/isPaymentMethods.js

@@ -0,0 +1,8 @@
+module.exports = () =>
+  function isPaymentMethods(modifier) {
+    return !!(
+      modifier &&
+      modifier.conditions &&
+      (modifier.conditions.paymentMethods || []).length
+    );
+  };

package/lib/modifier/isPaymentTypes.js

@@ -0,0 +1,8 @@
+module.exports = () =>
+  function isPaymentTypes(modifier) {
+    return !!(
+      modifier &&
+      modifier.conditions &&
+      (modifier.conditions.paymentTypes || []).length
+    );
+  };

package/lib/modifier/isPreferences.js

@@ -0,0 +1,8 @@
+module.exports = ({ settings, _ }) => {
+  const getPreferencesSettings = () => _.get(settings, 'types.preferences', []);
+
+  return function isPreferences(modifier) {
+    const preferences = getPreferencesSettings();
+    return modifier.group && preferences.includes(modifier.group.toLowerCase());
+  };
+};

package/lib/modifier/isPriceOverride.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function isPriceOverride(modifier) {
+    return !!(
+      actions.isOverride(modifier) &&
+      modifier.properties.override.field === 'price'
+    );
+  };

package/lib/modifier/isPromotion.js

@@ -0,0 +1,6 @@
+module.exports = ({ constants, actions }) => {
+  const { Modifier } = constants;
+  return function isPromotion(modifier) {
+    return actions.hasAttribute(modifier, Modifier.Attributes.PROMOTION);
+  };
+};

package/lib/modifier/isQuantityOverride.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function isQuantityOverride(modifier) {
+    return (
+      actions.isOverride(modifier) &&
+      modifier.properties.override.field === 'quantity'
+    );
+  };

package/lib/modifier/isRemoveModifier.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isRemoveModifier(modifier) {
+    return !!(modifier && (modifier.delModifiers || []).length);
+  };

package/lib/modifier/isRequired.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isRequired(modifier) {
+    return modifier && modifier.required;
+  };

package/lib/modifier/isRequiredAndOverride.js

@@ -0,0 +1,4 @@
+module.exports = ({ actions }) =>
+  function isRequiredAndOverride(modifier) {
+    return actions.isOverride(modifier) && actions.isRequired(modifier);
+  };

package/lib/modifier/isService.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function isService(modifier) {
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.override &&
+      modifier.properties.override.type === 'service'
+    );
+  };

package/lib/modifier/isSingleValue.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function isSingleValue(modifier) {
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.group &&
+      modifier.properties.group.singleValue
+    );
+  };

package/lib/modifier/isSubscription.js

@@ -0,0 +1,6 @@
+module.exports = ({ constants, actions }) => {
+  const { Modifier } = constants;
+  return function isSubscription(modifier) {
+    return actions.hasAttribute(modifier, Modifier.Attributes.SUBSCRIPTION);
+  };
+};

package/lib/modifier/isTrackUsageSubscription.js

@@ -0,0 +1,5 @@
+module.exports = ({ _ }) =>
+  function isTrackUsageSubscription(modifier) {
+    const subscription = _.get(modifier, 'properties.subscription');
+    return !!(subscription && subscription.enabled && subscription.trackUsage);
+  };

package/lib/modifier/isValueSelected.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function isValueSelected({ modifier, value }) {
+    if (!modifier || !value) return false;
+    if (!actions.isGroupOfValues(modifier)) return false;
+    if (!Array.isArray(modifier.properties.group.selectedValues)) return false;
+    return modifier.properties.group.selectedValues.includes(value);
+  };

package/lib/modifier/purifyModifiers.js

@@ -0,0 +1,15 @@
+module.exports = ({ actions }) =>
+  function purifyModifiers(modifiers) {
+    if (!modifiers) return [];
+    const removeIds = modifiers
+      .filter(modifier => actions.isRemoveModifier(modifier))
+      .reduce(
+        (acc, modifier) => [
+          ...acc,
+          modifier.properties.delModifiers.map(each => each._id),
+        ],
+        []
+      );
+
+    return modifiers.filter(each => !removeIds.includes(each.modifierId));
+  };

package/lib/modifier/sort.js

@@ -0,0 +1,35 @@
+/* eslint-disable no-prototype-builtins */
+module.exports = () => {
+  function compareValues(key, order = 'asc') {
+    return function innerSort(a, b) {
+      // property doesn't exist on either object
+      if (
+        !a.properties ||
+        !a.properties.hasOwnProperty(key) ||
+        !b.properties ||
+        !b.properties.hasOwnProperty(key)
+      )
+        return 0;
+
+      const varA =
+        typeof a.properties[key] === 'string'
+          ? a.properties[key].toUpperCase()
+          : a.properties[key];
+      const varB =
+        typeof b.properties[key] === 'string'
+          ? b.properties[key].toUpperCase()
+          : b.properties[key];
+
+      let comparison = 0;
+      if (varA > varB) comparison = 1;
+      else if (varA < varB) comparison = -1;
+      return order === 'desc' ? comparison * -1 : comparison;
+    };
+  }
+
+  return function sort(modifiers) {
+    if (!modifiers || !Array.isArray(modifiers)) return modifiers;
+    const compare = compareValues('sort');
+    return modifiers.sort(compare);
+  };
+};

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