@darkpos/pricing 1.0.6 → 1.0.7

package/__TEST__/modifier/sort.test.js

@@ -0,0 +1,41 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('Sort Function', () => {
+  test('usecase #1', () => {
+    const modifiers = [
+      {
+        _id: 1,
+        type: 'fixed',
+        action: 'add',
+        amount: 10,
+        name: 'someModifier',
+        properties: {},
+      },
+      {
+        _id: 2,
+        type: 'fixed',
+        action: 'add',
+        amount: 10,
+        name: 'someModifier',
+        properties: {
+          sort: 2,
+        },
+      },
+      {
+        _id: 3,
+        type: 'fixed',
+        action: 'add',
+        amount: 10,
+        name: 'someModifier',
+        properties: {
+          sort: 1,
+        },
+      },
+    ];
+    const sortedModifiers = pricingService.modifier.sort(modifiers);
+    const ids = sortedModifiers.map((mob) => mob._id);
+    expect(ids).toMatchObject([1, 3, 2]);
+  });
+});

package/__TEST__/order.test.js

@@ -229,6 +229,5 @@ describe('Order actions', () => {
       discount: -1,
       tax: 2,
     });
-    console.log('order =>', JSON.stringify(newOrder, 0, 2));
   });
 });

package/lib/constants/Modifier/Attributes.js

@@ -0,0 +1,9 @@
+//
+module.exports = {
+  SUBSCRIPTION: 'subscription',
+  PROMOTION: 'promotion',
+  GROUP: 'group',
+  LIST: 'list',
+  DEPARTMENT: 'department',
+  OVERRIDE: 'override',
+};

package/lib/constants/Modifier/Compute.js

@@ -0,0 +1,15 @@
+const Types = {
+  FIXED: 'fixed',
+  PERCENTAGE: 'percentage',
+};
+
+const Actions = {
+  ADD: 'add',
+  SUBTRACT: 'subtract',
+  OVERRIDE: 'override',
+};
+
+module.exports = {
+  Types,
+  Actions,
+};

package/lib/constants/Modifier/Types.js

@@ -0,0 +1,7 @@
+//
+module.exports = {
+  DISCOUNT: 'discount',
+  TAX: 'tax',
+  GRATUITY: 'gratuity',
+  CREDIT: 'credit',
+};

package/lib/constants/Modifier/index.js

@@ -0,0 +1,9 @@
+const Compute = require('./Compute');
+const Types = require('./Types');
+const Attributes = require('./Attributes');
+
+module.exports = {
+  Attributes,
+  Types,
+  Compute,
+};

package/lib/constants/index.js

@@ -1,5 +1,7 @@
-const status = require('./status');
+const Status = require('./Status');
+const Modifier = require('./Modifier');
 
 module.exports = {
-  status,
+  Status,
+  Modifier,
 };

package/lib/index.js

@@ -1,10 +1,11 @@
-const makeModifierService = require('@darkpos/modifier');
 const utils = require('@darkpos/utils');
 const _ = require('lodash');
 const moment = require('moment-timezone');
 /** services  */
 const makeItemActions = require('./item');
 const makeOrderActions = require('./order');
+const makeModifierActions = require('./modifier');
+const constants = require('./constants');
 
 module.exports = session => {
   const { useLocalization } = utils;
@@ -17,10 +18,11 @@ module.exports = session => {
     localization,
     _,
     moment,
+    constants,
   };
 
   //
-  const modifierActions = makeModifierService(session);
+  const modifierActions = makeModifierActions(deps);
   const itemActions = makeItemActions({ ...deps, modifierActions });
   const orderActions = makeOrderActions({
     ...deps,

package/lib/item/getItemsTotalPieces.js

@@ -1,7 +1,7 @@
 module.exports = ({ actions }) =>
   function getItemsTotalPieces(items) {
     return items.reduce(
-      (total, item) => total + actions.getItemTotalPieces(item),
+      (total, item) => total + actions.getTotalPieces(item),
       0
     );
   };

package/lib/modifier/addFile.js

@@ -0,0 +1,19 @@
+module.exports = ({ actions }) =>
+  function addFile({ modifier, file, add = true }) {
+    if (!modifier || !file || !actions.isGroupOfValues(modifier)) return null;
+    let files = [...(modifier.properties.group.files || [])];
+
+    if (add) files.push(file);
+    else files = files.filter(each => each._id !== file._id);
+
+    return {
+      ...modifier,
+      properties: {
+        ...modifier.properties,
+        group: {
+          ...modifier.properties.group,
+          files,
+        },
+      },
+    };
+  };

package/lib/modifier/addImage.js

@@ -0,0 +1,18 @@
+module.exports = ({ actions }) =>
+  function addImage({ modifier, image, add = true }) {
+    if (!modifier || !image || !actions.isGroupOfValues(modifier)) return null;
+    let images = [...(modifier.properties.group.images || [])];
+    if (add) images.push(image);
+    else images = images.filter(each => each !== image);
+
+    return {
+      ...modifier,
+      properties: {
+        ...modifier.properties,
+        group: {
+          ...modifier.properties.group,
+          images,
+        },
+      },
+    };
+  };

package/lib/modifier/calculate.js

@@ -0,0 +1,43 @@
+/**
+ * Get calculated modifier
+ */
+module.exports = ({ _, constants, utils, localization, actions }) => {
+  const { math } = utils;
+  const { Modifier } = constants;
+
+  return function calculate(
+    modifier = {},
+    options = { price: 0, skip: false }
+  ) {
+    const { name, compute } = modifier;
+    const { type, action, amount = 0 } = compute || {};
+    const _computed = {
+      amount: 0,
+      description: '',
+    };
+    const maxAmount = actions.getProperty(modifier, 'maxAmount');
+    if (!options.skip) {
+      const multiplier = action === Modifier.Compute.Actions.SUBTRACT ? -1 : 1;
+
+      if (type === Modifier.Compute.Types.FIXED)
+        _computed.amount = math.mul(multiplier, amount);
+
+      if (type === Modifier.Compute.Types.PERCENTAGE)
+        _computed.amount = math.div(
+          math.mul(multiplier, options.price, amount),
+          100
+        );
+
+      if (!type || action === Modifier.Compute.Actions.OVERRIDE)
+        _computed.amount = amount;
+
+      if (maxAmount && math.gt(math.abs(_computed.amount), maxAmount))
+        _computed.amount = maxAmount;
+    }
+
+    const localAmount = localization.formatAmount(_computed.amount);
+    _computed.description = `${name} (${localAmount})`;
+
+    return { ..._.cloneDeep(modifier), _computed };
+  };
+};

package/lib/modifier/contains.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function contains(modifiers = [], modifier = null) {
+    if (!modifiers || !modifier) return false;
+    return !!modifiers.find(each => each.modifierId === modifier._id);
+  };

package/lib/modifier/convertMenuModifiers.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function convertMenuModifiers(menuModifiers) {
+    if (!Array.isArray(menuModifiers)) return [];
+    return menuModifiers.map(each => each.modifier || each);
+  };

package/lib/modifier/create.js

@@ -0,0 +1,44 @@
+module.exports = ({ utils }) => {
+  const { helpers } = utils;
+
+  const defaults = {
+    name: '',
+    sku: '',
+    description: '',
+    group: '',
+    type: '',
+    attributes: [],
+    color: '',
+    backgroundColor: '',
+    icon: '',
+    url: '',
+    code: '',
+    tags: [],
+    order: 0,
+    included: false,
+    direct: true,
+    hidden: false,
+    required: false,
+    print: true,
+    delModifiers: [],
+    addModifiers: [],
+    conditions: null,
+    compute: null,
+    properties: {},
+    get _id() {
+      return helpers.getObjectID();
+    },
+    modifierId: null,
+    __typename: 'Modifier',
+  };
+
+  return function create(params) {
+    const { _id, modifierId, ...modifier } = params;
+    const parentId = modifierId || _id;
+    return {
+      ...defaults,
+      ...modifier,
+      modifierId: parentId,
+    };
+  };
+};

package/lib/modifier/createAmountOverrideModifier.js

@@ -0,0 +1,20 @@
+module.exports = ({ constants, actions, utils }) => {
+  const { Modifier } = constants;
+  const { helpers } = utils;
+
+  return function createAmountOverrideModifier(params) {
+    return actions.create({
+      compute: {
+        amount: params.amount,
+        action: Modifier.Compute.Actions.OVERRIDE,
+      },
+      properties: {
+        override: { field: 'amount' },
+      },
+      attributes: [Modifier.Attributes.OVERRIDE],
+      name: `Modifier Amount ${Modifier.Compute.Actions.OVERRIDE}`,
+      included: true,
+      _id: helpers.getObjectID(),
+    });
+  };
+};

package/lib/modifier/createCreditModifier.js

@@ -0,0 +1,32 @@
+module.exports = ({ _, actions, utils }) => {
+  const { helpers } = utils;
+  //
+  return function createCreditModifier(modifier = {}) {
+    const { customerStoredCredit, ...rest } = _.cloneDeep(modifier);
+    if (!customerStoredCredit) return null;
+    let creditModifier;
+    if (!_.isEmpty(rest)) {
+      creditModifier = rest;
+    }
+    // create one
+    else {
+      creditModifier = actions.create({
+        _id: helpers.getObjectID(),
+        type: 'credit',
+        name: 'Customer stored credit',
+        direct: true,
+      });
+    }
+
+    creditModifier.compute = {
+      amount: 100,
+      type: 'percentage',
+      action: 'subtract',
+    };
+    creditModifier.properties = {
+      maxAmount: customerStoredCredit,
+      sort: 999,
+    };
+    return creditModifier;
+  };
+};

package/lib/modifier/createDiscountModifier.js

@@ -0,0 +1,25 @@
+module.exports = ({ constants, actions, localization, utils }) => {
+  const { helpers } = utils;
+  const { Modifier } = constants;
+
+  return function createDiscountModifier(params) {
+    const { amount, type } = params;
+    const { formatAmount } = localization;
+
+    const name =
+      type === Modifier.Compute.Types.PERCENTAGE
+        ? `${amount}%`
+        : `${formatAmount(amount)}`;
+
+    return actions.create({
+      compute: {
+        action: Modifier.Compute.Actions.SUBTRACT,
+        amount,
+        type,
+      },
+      type: Modifier.Types.DISCOUNT,
+      name: `${name} ${Modifier.Types.DISCOUNT}`,
+      _id: helpers.getObjectID(),
+    });
+  };
+};

package/lib/modifier/createGroupValuesModifier.js

@@ -0,0 +1,29 @@
+module.exports = ({ actions }) =>
+  function createGroupValuesModifier({ modifier, value, add = false }) {
+    if (!modifier || !value || !actions.isGroupOfValues(modifier)) return null;
+
+    const multiSelect = !actions.isSingleValue(modifier);
+    let selectedValues = [];
+    const modifierValues = [...modifier.properties.group.values, value];
+
+    if (!add) {
+      selectedValues = [...(modifier.properties.group.selectedValues || [])];
+      const remove = selectedValues.includes(value);
+      if (remove)
+        selectedValues = selectedValues.filter(each => each !== value);
+      else if (multiSelect) selectedValues.push(value);
+      else selectedValues = [value];
+    }
+
+    return {
+      ...modifier,
+      properties: {
+        ...modifier.properties,
+        group: {
+          ...modifier.properties.group,
+          selectedValues,
+          values: add ? [...new Set(modifierValues)] : [],
+        },
+      },
+    };
+  };

package/lib/modifier/createIndirectModifier.js

@@ -0,0 +1,42 @@
+/*
+ * create a distrubuted Modifier based on Order and Item
+ */
+module.exports = ({ _, utils, constants, actions }) => {
+  const { math } = utils;
+  const { Modifier } = constants;
+
+  return function createIndirectModifier(
+    modifier,
+    options = { orderTotal: 0, itemTotal: 0, itemQuantity: 1 }
+  ) {
+    const { compute = {} } = modifier;
+    const { type, amount = 0 } = compute;
+    let modifierAmount = amount;
+
+    if (type === Modifier.Compute.Types.PERCENTAGE)
+      modifierAmount = math.div(math.mul(options.orderTotal, amount), 100);
+
+    let amountToApply = 0;
+
+    if (!math.isZero(options.orderTotal))
+      amountToApply = math.div(
+        math.mul(modifierAmount, options.itemTotal),
+        options.orderTotal,
+        options.itemQuantity
+      );
+
+    const modifierToAdd = actions.create({
+      ..._.cloneDeep(modifier),
+      direct: false,
+      compute: {
+        type: Modifier.Compute.Types.FIXED,
+        amount: amountToApply,
+        action: compute.action || Modifier.Compute.Actions.SUBTRACT,
+      },
+    });
+    if (actions.getProperty(modifierToAdd, 'maxAmount') !== null)
+      delete modifierToAdd.properties.maxAmount;
+
+    return modifierToAdd;
+  };
+};

package/lib/modifier/createSubscriptionModifier.js

@@ -0,0 +1,19 @@
+module.exports = ({ constants, actions, utils }) => {
+  const { Modifier } = constants;
+  const { helpers } = utils;
+
+  return function createSubscriptionModifier(params = {}) {
+    return actions.create({
+      compute: {
+        action: Modifier.Compute.Actions.SUBTRACT,
+        type: Modifier.Compute.Types.FIXED,
+        amount: params.amount,
+      },
+      attributes: [Modifier.Attributes.SUBSCRIPTION],
+      name: Modifier.Attributes.SUBSCRIPTION,
+      type: Modifier.Types.DISCOUNT,
+      _id: helpers.getObjectID(),
+      ...params,
+    });
+  };
+};

package/lib/modifier/displayAsCard.js

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

package/lib/modifier/displayAsChips.js

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

package/lib/modifier/displayAsList.js

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

package/lib/modifier/duplicate.js

@@ -0,0 +1,12 @@
+module.exports = ({ utils }) => {
+  const { helpers } = utils;
+  return function duplicate(modifier) {
+    if (!modifier) return null;
+
+    return {
+      ...modifier,
+      modifierId: modifier.modifierId || modifier._id,
+      _id: helpers.getObjectID(),
+    };
+  };
+};

package/lib/modifier/enableAutoPopup.js

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

package/lib/modifier/filterByRequiredModifiers.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function filterByRequiredModifiers(modifiers) {
+    return modifiers.filter(each => each.required);
+  };

package/lib/modifier/findById.js

@@ -0,0 +1,7 @@
+module.exports = () =>
+  function findById(modifiers, id) {
+    if (!Array.isArray(modifiers)) return null;
+    return modifiers
+      .filter(Boolean)
+      .find(each => each._id === id || each.modifierId === id);
+  };

package/lib/modifier/findByPaymentMethod.js

@@ -0,0 +1,10 @@
+module.exports = ({ actions }) =>
+  function findByPaymentMethod({ modifiers, paymentMethod = '' }) {
+    if (!Array.isArray(modifiers) || !paymentMethod) return null;
+
+    return modifiers.find(
+      each =>
+        actions.isPaymentMethods(each) &&
+        each.conditions.paymentMethods.includes(paymentMethod)
+    );
+  };

package/lib/modifier/findByPaymentType.js

@@ -0,0 +1,10 @@
+module.exports = ({ actions }) =>
+  function findByPaymentType({ modifiers, paymentType = '' }) {
+    if (!Array.isArray(modifiers) || !paymentType) return null;
+
+    return modifiers.find(
+      each =>
+        actions.isPaymentTypes(each) &&
+        each.conditions.paymentTypes.includes(paymentType)
+    );
+  };

package/lib/modifier/getAvailablePromotions.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getAvailablePromotions(modifiers) {
+    if (!Array.isArray(modifiers)) return [];
+    return modifiers.filter(each => actions.isAvailablePromotion(each));
+  };

package/lib/modifier/getAvailablePromotionsOrSubscriptions.js

@@ -0,0 +1,15 @@
+module.exports = ({ actions }) =>
+  /*
+   * This function will receive a list of promotion modifiers and filter them by the limits that we have for promotions
+   * Filters are:
+   *  modifier.properties.promotion.dateLimit.{from, to} which compares today with these two dates
+   *  modifier.properties.promotion.numberOfUsesLimit which will be checked with modifier.properties.promotion.numberOfUses
+   */
+  function getAvailablePromotionsOrSubscriptions(modifiers) {
+    if (!Array.isArray(modifiers)) return [];
+    return modifiers.filter(
+      each =>
+        actions.isAvailableSubscription(each) ||
+        actions.isAvailablePromotion(each)
+    );
+  };

package/lib/modifier/getAvailableSubscriptions.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getAvailableSubscriptions(modifiers) {
+    if (!Array.isArray(modifiers)) return [];
+    return modifiers.filter(each => actions.isAvailableSubscription(each));
+  };

package/lib/modifier/getByAttribute.js

@@ -0,0 +1,6 @@
+module.exports = ({ actions }) =>
+  //
+  function getByAttribute(modifiers, attribute) {
+    if (!modifiers) return [];
+    return modifiers.filter(each => actions.hasAttribute(each, attribute));
+  };

package/lib/modifier/getCreditModifier.js

@@ -0,0 +1,6 @@
+module.exports = ({ actions }) =>
+  //
+  function getCreditModifier(modifiers) {
+    if (!modifiers) return null;
+    return modifiers.find(actions.isCredit);
+  };

package/lib/modifier/getDefaultModifiers.js

@@ -0,0 +1,4 @@
+module.exports = ({ actions }) =>
+  function getDefaultModifiers(modifiers) {
+    return (modifiers || []).filter(each => actions.isDefault(each));
+  };

package/lib/modifier/getDepartmentMaxItems.js

@@ -0,0 +1,10 @@
+module.exports = () =>
+  function getDepartmentMaxItems(modifier) {
+    return (
+      (modifier &&
+        modifier.properties &&
+        modifier.properties.department &&
+        modifier.properties.department.maxItems) ||
+      0
+    );
+  };

package/lib/modifier/getDepartmentModifiers.js

@@ -0,0 +1,11 @@
+module.exports = ({ actions, utils }) => {
+  const { math } = utils;
+  const getOrder = modifier => (modifier && modifier.order) || 0;
+
+  return function getDepartmentModifiers(modifiers) {
+    if (!modifiers || !Array.isArray(modifiers)) return [];
+    return modifiers
+      .filter(each => actions.isDepartment(each))
+      .sort((mod1, mod2) => math.sub(getOrder(mod1), getOrder(mod2)));
+  };
+};

package/lib/modifier/getDescription.js

@@ -0,0 +1,6 @@
+module.exports = () =>
+  function getDescription(modifier) {
+    return (
+      (modifier && modifier._computed && modifier._computed.description) || ''
+    );
+  };

package/lib/modifier/getDescriptions.js

@@ -0,0 +1,9 @@
+module.exports = ({ actions }) =>
+  function getDescriptions(modifiers) {
+    if (!Array.isArray(modifiers)) return '';
+
+    const descriptions = modifiers
+      .map(each => actions.getDescription(each))
+      .filter(Boolean);
+    return descriptions.join(', ');
+  };

package/lib/modifier/getDirectModifiers.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getDirectModifiers(modifiers) {
+    if (!Array.isArray(modifiers)) return [];
+    return modifiers.filter(each => actions.isDirect(each));
+  };