@darkpos/pricing 1.0.81 → 1.0.84

package/__TEST__/modifier.test.js

@@ -1667,4 +1667,192 @@ describe('Modifier actions', () => {
 
     expect(currentOrder.total).toEqual(495);
   });
+
+  test('CU-86dve295v should split item based on modifier.maxItemQuantity=1, and spread modifiers accordingly. Having Percentage Modifier', () => {
+    const order = {
+      id: 'ord-456',
+      items: [],
+      modifiers: [],
+    };
+
+    const mod10Percent = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'percentage',
+      },
+      modifierId: '111',
+    };
+
+    const modifier = {
+      _id: 2,
+      properties: {
+        limits: { maxItemQuantity: 1 },
+      },
+      modifierId: '222',
+    };
+
+    let currentOrder = { ...order };
+
+    currentOrder = pricingService.order.addItem({
+      order,
+      item: {
+        quantity: 10,
+        itemId: '222',
+        price: 10,
+        modifiers: [],
+        subTotals: {},
+      },
+    }).updatedOrder;
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier: mod10Percent,
+      itemIndex: 0,
+    });
+
+    currentOrder = pricingService.order.calculate(currentOrder);
+    expect(currentOrder.total).toEqual(99);
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 0,
+    });
+
+    currentOrder = pricingService.order.calculate(currentOrder);
+
+    expect(currentOrder.items.length).toEqual(1);
+
+    expect(currentOrder.total).toEqual(99);
+
+    currentOrder = pricingService.order.splitItems({
+      order: currentOrder,
+    });
+
+    currentOrder.items.forEach(item => {
+      expect(item.quantity).toEqual(1);
+      expect(item.price).toEqual(10);
+      expect(item.modifiers[0]._computed.amount).toEqual(0);
+      expect(item.modifiers[1]._computed.amount).toEqual(-0.1);
+    });
+
+    expect(currentOrder.total).toEqual(99);
+  });
+
+  test('Should allow adding a modifier more than once to an item if isQuantityMultiplier={false} QTY={2} required=true', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      required: true,
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    const updatedOrder = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+    });
+
+    let error = '';
+    const updatedOrder2 = pricingService.order.addItemModifier({
+      order: { ...updatedOrder },
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+      onError: errorMessage => {
+        error = errorMessage;
+      },
+    });
+
+    expect(conditionsBag).toEqual([]);
+    expect(error).toEqual('');
+
+    expect(updatedOrder2.items[0].modifiers.length).toEqual(2);
+  });
+
+  test('Should not allow adding a modifier more than once to an item if isQuantityMultiplier={false} QTY={2} required=true', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: true,
+      },
+      required: true,
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    const updatedOrder = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+    });
+
+    let error = '';
+    const updatedOrder2 = pricingService.order.addItemModifier({
+      order: { ...updatedOrder },
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+      onError: errorMessage => {
+        error = errorMessage;
+      },
+    });
+
+    expect(conditionsBag).toEqual([]);
+    expect(error).toEqual('modifier.has.reached.the.maximum.amount.of.applies');
+
+    expect(updatedOrder2.items[0].modifiers.length).toEqual(1);
+  });
 });

package/__TEST__/order/order.test.js

@@ -3863,4 +3863,32 @@ describe('Order actions', () => {
 
     expect(currentOrder.modifiers.length).toBe(2);
   });
+  test('Get calculated Order, one item with correct rounded amount in modifier description', () => {
+    const discountModifier = {
+      compute: {
+        amount: 30,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: 'modifier1',
+      type: 'discount',
+    };
+
+    const orderItem = {
+      price: 3.65,
+      quantity: 1,
+      modifiers: [discountModifier],
+    };
+    const order = { items: [orderItem] };
+    const newOrder = pricingService.order.calculate(order);
+
+    expect(newOrder).toHaveProperty('total', 2.56);
+    expect(newOrder.items[0].modifiers[0]._computed.amount).toEqual(-1.09);
+    expect(newOrder.items[0].modifiers[0]._computed.description).toEqual(
+      'modifier1 (-$1.09)'
+    );
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -1.09,
+    });
+  });
 });

package/lib/item/calculate.js

@@ -2,6 +2,7 @@
 module.exports = ({ _, utils, actions, modifierActions }) => {
   const { math } = utils;
   //
+
   const calculateOne = (inputItem, opts = {}) => {
     const item = _.cloneDeep(inputItem);
     const amountToPay =
@@ -17,7 +18,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
 
     if (!item) return item;
 
-    const subTotals = {
+    let subTotals = {
       _included: 0,
       _xincluded: 0,
       _direct: 0,
@@ -169,18 +170,13 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         prvPrice = math.add(prvPrice, math.div(_computed.amount, quantity));
         prvSort = sort;
 
-        if (included) {
-          subTotals._included = math.add(subTotals._included, computedAmount);
-        } else {
-          subTotals._xincluded = math.add(subTotals._xincluded, computedAmount);
-          subTotals[type] = math.add(subTotals[type] || 0, computedAmount);
-        }
-        if (direct)
-          subTotals._direct = math.add(subTotals._direct, computedAmount);
-        else subTotals._xdirect = math.add(subTotals._xdirect, computedAmount);
-
-        subTotals._actual = math.add(subTotals._simple, subTotals._included);
-        total = actions.getTotal({ subTotals });
+        ({ subTotals, total } = actions.getTotals({
+          subTotals,
+          amountToAdd: computedAmount,
+          included,
+          type,
+          direct,
+        }));
       }
     }
 

package/lib/item/getTotals.js

@@ -0,0 +1,27 @@
+module.exports = ({ utils, actions }) => {
+  const { math } = utils;
+  return function getTotals({
+    subTotals: subTotalsParam,
+    amountToAdd,
+    included,
+    type,
+    direct,
+  }) {
+    const subTotals = { ...subTotalsParam };
+    if (included) {
+      subTotals._included = math.add(subTotals._included, amountToAdd);
+    } else {
+      subTotals._xincluded = math.add(subTotals._xincluded, amountToAdd);
+      subTotals[type] = math.add(subTotals[type] || 0, amountToAdd);
+    }
+    if (direct) subTotals._direct = math.add(subTotals._direct, amountToAdd);
+    else subTotals._xdirect = math.add(subTotals._xdirect, amountToAdd);
+
+    subTotals._actual = math.add(subTotals._simple, subTotals._included);
+
+    return {
+      subTotals,
+      total: actions.getTotal({ subTotals }),
+    };
+  };
+};

package/lib/item/index.js

@@ -59,6 +59,8 @@ const adjustFixedModifiersDifference = require('./adjustFixedModifiersDifference
 const validateCreditModifiersTotal = require('./validateCreditModifiersTotal');
 const adjustCreditModifiersDifference = require('./adjustCreditModifiersDifference');
 const getSubtotal = require('./getSubtotal');
+const getTotals = require('./getTotals');
+const patchItem = require('./patchItem');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -131,6 +133,8 @@ const itemActions = (deps = {}) => {
     validateCreditModifiersTotal: validateCreditModifiersTotal(innerDeps),
     adjustCreditModifiersDifference: adjustCreditModifiersDifference(innerDeps),
     getSubtotal: getSubtotal(innerDeps),
+    getTotals: getTotals(innerDeps),
+    patchItem: patchItem(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/patchItem.js

@@ -0,0 +1,31 @@
+module.exports = ({ actions, modifierActions }) =>
+  function patchItem({ item, difference }) {
+    if (!item) return undefined;
+
+    const localItem = { ...item };
+
+    const modifierIndex = item.modifiers.findIndex(
+      mod => modifierActions.isPercentage(mod) || !modifierActions.isDirect(mod)
+    );
+
+    localItem.modifiers[modifierIndex] = modifierActions.patchModifier({
+      mod: localItem.modifiers[modifierIndex],
+      difference,
+      price: actions.getBasePrice(localItem) || localItem.price,
+    });
+
+    const { included, type, direct } = localItem.modifiers[modifierIndex];
+
+    const result = actions.getTotals({
+      subTotals: localItem.subTotals,
+      amountToAdd: difference,
+      included,
+      type,
+      direct,
+    });
+
+    localItem.subTotals = result.subTotals;
+    localItem.total = result.total;
+
+    return localItem;
+  };

package/lib/item/splitAndCalculate.js

@@ -10,9 +10,11 @@ module.exports = ({ actions, modifierActions }) =>
         modifiers: modifierActions.getSplittedModifiers(
           parentItem.modifiers,
           parentSubTotal,
-          subTotal
+          subTotal,
+          subItems.length
         ),
       };
+
       return actions.calculate(newItem);
     });
   };

package/lib/modifier/calculate.js

@@ -3,7 +3,7 @@ const { getComputeModField } = require('./utils');
 /**
  * Get calculated modifier
  */
-module.exports = ({ _, constants, utils, localization, actions }) => {
+module.exports = ({ _, constants, utils, actions }) => {
   const { math } = utils;
   const { Modifier } = constants;
 
@@ -12,7 +12,6 @@ module.exports = ({ _, constants, utils, localization, actions }) => {
     options = { price: 0, quantity: 0, skip: false, basePrice: 0 }
   ) {
     const modifier = _modifier;
-    const { name } = modifier;
     const compute = getComputeModField(modifier);
     const { type, amount: computeAmount = 0 } = compute;
     const _computed = {
@@ -71,42 +70,14 @@ module.exports = ({ _, constants, utils, localization, actions }) => {
       }
     }
 
-    const localAmount =
-      !!_computed.amount && Number(_computed.amount) !== 0
-        ? `${localization.formatAmount(_computed.amount)}`
-        : '';
-
-    const localBasePrice = localization.formatAmount(
-      options.basePrice || options.price || 0
-    );
-
-    const isMultiplier = actions.isMultiplier(modifier);
-
-    _computed.description = `${name}${localAmount ? ` (${localAmount})` : ''}`;
-
-    if (actions.isPriceOverride(modifier)) {
-      _computed.description = isMultiplier
-        ? `${name} (${compute.amount} Unit @ ${localBasePrice}/Unit)`
-        : `${name} (${localization.formatAmount(compute.amount)}/Unit)`;
-    }
-
-    if (actions.isAmountOverride(modifier) && isMultiplier) {
-      _computed.description = `${name} (${localization.formatAmount(
-        _computed.amount
-      )})`;
-    }
-
-    if (actions.isOptionsSelectedOverride(modifier)) {
-      const selectedOverrideOptions = _.get(
-        modifier,
-        'properties.override.selected'
-      );
-      _computed.description = isMultiplier
-        ? `${name} (${compute.amount} Unit @ ${localBasePrice}/${selectedOverrideOptions.selectedUnit})`
-        : `${name} (${localization.formatAmount(compute.amount)}/${
-            selectedOverrideOptions.selectedUnit
-          })`;
-    }
+    _computed.description = actions.createDescription({
+      modifier: {
+        ...modifier,
+        compute,
+        _computed,
+      },
+      price: options.basePrice || options.price,
+    });
 
     return { ..._.cloneDeep(modifier), _computed };
   };

package/lib/modifier/createDescription.js

@@ -0,0 +1,40 @@
+module.exports = ({ actions, localization, _ }) =>
+  function createDescription({ modifier, price }) {
+    const { _computed, compute, name } = modifier;
+
+    let description = '';
+    const localAmount =
+      !!_computed.amount && Number(_computed.amount) !== 0
+        ? `${localization.formatAmount(_computed.amount)}`
+        : '';
+
+    const localBasePrice = localization.formatAmount(price || 0);
+
+    const isMultiplier = actions.isMultiplier(modifier);
+
+    description = `${name}${localAmount ? ` (${localAmount})` : ''}`;
+
+    if (actions.isPriceOverride(modifier)) {
+      description = isMultiplier
+        ? `${name} (${compute.amount} Unit @ ${localBasePrice}/Unit)`
+        : `${name} (${localization.formatAmount(compute.amount)}/Unit)`;
+    }
+
+    if (actions.isAmountOverride(modifier) && isMultiplier) {
+      description = `${name} (${localization.formatAmount(_computed.amount)})`;
+    }
+
+    if (actions.isOptionsSelectedOverride(modifier)) {
+      const selectedOverrideOptions = _.get(
+        modifier,
+        'properties.override.selected'
+      );
+      description = isMultiplier
+        ? `${name} (${compute.amount} Unit @ ${localBasePrice}/${selectedOverrideOptions.selectedUnit})`
+        : `${name} (${localization.formatAmount(compute.amount)}/${
+            selectedOverrideOptions.selectedUnit
+          })`;
+    }
+
+    return description;
+  };

package/lib/modifier/getSplittedModifiers.js

@@ -1,4 +1,4 @@
-module.exports = ({ utils }) => {
+module.exports = ({ utils, actions }) => {
   const { math } = utils;
   const { getComputeModField } = require('./utils');
 
@@ -47,7 +47,12 @@ module.exports = ({ utils }) => {
     };
   };
 
-  return function getSplittedModifiers(modifiers, totalOrigin, totalSplited) {
+  return function getSplittedModifiers(
+    modifiers,
+    totalOrigin,
+    totalSplited,
+    itemsLength
+  ) {
     return modifiers.map(each => {
       const modifier = { ...each };
       const compute = getComputeModField(modifier);
@@ -66,6 +71,22 @@ module.exports = ({ utils }) => {
           totalSplited,
         });
       }
+
+      if (
+        compute &&
+        compute.type === 'percentage' &&
+        compute.amount &&
+        !actions.isQuantityMultiplier(modifier)
+      ) {
+        return {
+          ...modifier,
+          compute: {
+            ...modifier.compute,
+            amount: math.div(modifier.compute.amount, itemsLength),
+          },
+        };
+      }
+
       return modifier;
     });
   };

package/lib/modifier/index.js

@@ -161,6 +161,8 @@ const isLimits = require('./isLimits');
 const isItemSet = require('./isItemSet');
 const isOrderUseValid = require('./isOrderUseValid');
 const getMaxItemQuantity = require('./getMaxItemQuantity');
+const createDescription = require('./createDescription');
+const patchModifier = require('./patchModifier');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -335,6 +337,8 @@ const modifierActions = (deps = {}) => {
     getMaxItemQuantity: getMaxItemQuantity(innerDeps),
     getFixedModifiersTotalEntities: getFixedModifiersTotalEntities(innerDeps),
     getCreditModifiersTotalEntities: getCreditModifiersTotalEntities(innerDeps),
+    createDescription: createDescription(innerDeps),
+    patchModifier: patchModifier(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/patchModifier.js

@@ -0,0 +1,21 @@
+module.exports = ({ utils, actions }) =>
+  function patchModifier({ mod, difference, price }) {
+    if (!mod || !mod._computed) return mod;
+
+    const modifier = { ...mod };
+
+    modifier._computed.amount = utils.math.add(
+      modifier._computed.amount,
+      difference
+    );
+
+    modifier._computed.description = actions.createDescription({
+      modifier: {
+        ...modifier,
+        _computed: modifier._computed,
+      },
+      price,
+    });
+
+    return modifier;
+  };

package/lib/order/addItemModifier.js

@@ -184,11 +184,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     const contains =
       !_.isEmpty(item.modifiers) &&
       modifierActions.contains(
-        item.modifiers.filter(
-          mod =>
-            !modifierActions.isRequired(mod) &&
-            !modifierActions.isGroupOfModifiers(mod)
-        ),
+        item.modifiers.filter(mod => !modifierActions.isGroupOfModifiers(mod)),
         modifier
       );
 

package/lib/order/calculate.js

@@ -108,19 +108,38 @@ module.exports = ({
     }
 
     const addToItemTotal = difference => {
-      if (difference > 0 && calculatedItems.length) {
+      if (difference !== 0 && calculatedItems.length) {
         calculatedItems[0].total = utils.math.toDecimalPlaces(
           utils.math.add(calculatedItems[0].total, difference)
         );
       }
     };
 
-    if (calculatedItems.length > 1) {
-      const difference = itemActions.getTotalsDifference({
+    if (calculatedItems.length > 0) {
+      let difference = itemActions.getTotalsDifference({
         items: calculatedItems,
       });
 
-      addToItemTotal(difference);
+      if (difference < 0) {
+        difference = difference < -0.005 ? 0 : utils.math.abs(difference);
+      }
+
+      const itemIndex = calculatedItems.findIndex(
+        item =>
+          !itemActions.isFullyPaid(item) &&
+          item.modifiers.some(
+            mod =>
+              modifierActions.isPercentage(mod) ||
+              !modifierActions.isDirect(mod)
+          )
+      );
+
+      if (itemIndex >= 0 && difference >= 0.005) {
+        calculatedItems[itemIndex] = itemActions.patchItem({
+          item: calculatedItems[itemIndex],
+          difference,
+        });
+      }
     }
 
     if (storeActions.isNeareastMultiple() && calculatedItems.length > 0) {

package/lib/order/removeItemModifier.js

@@ -40,7 +40,14 @@ module.exports = ({ actions, modifierActions, itemActions, utils, _ }) => {
     originalItem,
   }) {
     const order = _.cloneDeep(orderProp);
-    if (!order || itemIndex < 0 || !modifier) return order;
+
+    if (
+      !order ||
+      itemIndex < 0 ||
+      !modifier ||
+      modifierActions.isRequired(modifier)
+    )
+      return order;
 
     let item = actions.getSelectedItem({ order, itemIndex });
     const customer = actions.getCustomer(order);

package/lib/order/splitAndCalculate.js

@@ -8,7 +8,8 @@ module.exports = ({ actions, modifierActions }) =>
         modifiers: modifierActions.getSplittedModifiers(
           parentOrder.modifiers,
           parentOrder.subTotal,
-          subTotal
+          subTotal,
+          subOrders.length
         ),
       };
       return actions.calculate(newOrder);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.81",
+  "version": "1.0.84",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -51,5 +51,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "41babe2d2f61ea0fac42d1f76c1c98a3afde8507"
+  "gitHead": "d15a98cdefcf27cdaf41a8096a6c6c7dcdfcc13f"
 }