@darkpos/pricing 1.0.81 → 1.0.83

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/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/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/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/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.83",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -51,5 +51,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "41babe2d2f61ea0fac42d1f76c1c98a3afde8507"
+  "gitHead": "d52fea81582a64b1ca707af442d41981ed6ce78d"
 }