@darkpos/pricing 1.0.79 → 1.0.81

package/__TEST__/order/conditionsNotMet.test.js

@@ -680,4 +680,208 @@ describe('Conditions not met for the item', () => {
     expect(order.items[5].total).toBe(5);
     expect(order.items[5].modifiers.length).toBe(1);
   });
+
+  test('#8: Item number condition is met using aggregatedItems, rule is lastSelected', () => {
+    const mod3x2 = {
+      _id: '68069a18766f8687858461e7',
+      name: '3x2',
+      properties: {},
+      type: 'discount',
+      tags: ['default'],
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'itemSet',
+            value: { itemSet: '3', itemRule: 'lastSelected' },
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 100,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 3,
+    };
+
+    let order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item,
+    }).updatedOrder;
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+
+    expect(order.items.length).toEqual(1);
+
+    order = pricingService.order.calculate(order);
+
+    expect(order.total).toBe(20);
+    expect(order.items[0].total).toBe(20);
+    expect(order.items[0].modifiers.length).toBe(1);
+  });
+
+  test('#9: Item number condition is met using aggregatedItems and others, rule is lastSelected', () => {
+    const mod3x2 = {
+      _id: '68069a18766f8687858461e7',
+      name: '3x2',
+      properties: {},
+      type: 'discount',
+      tags: ['default'],
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'itemSet',
+            value: { itemSet: '3', itemRule: 'lastSelected' },
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 100,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 2,
+    };
+
+    const item2 = {
+      _id: 'bcd',
+      price: 10,
+      quantity: 1,
+    };
+
+    let order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item,
+    }).updatedOrder;
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+
+    order = pricingService.order.addItem({
+      order,
+      item: item2,
+    }).updatedOrder;
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+
+    expect(order.items.length).toEqual(2);
+
+    order = pricingService.order.calculate(order);
+
+    expect(order.total).toBe(20);
+    expect(order.items[0].total).toBe(0);
+    expect(order.items[0].modifiers.length).toBe(1);
+    expect(order.items[1].total).toBe(20);
+    expect(order.items[1].modifiers.length).toBe(1);
+  });
+
+  test('#10: Item number condition is met using aggregatedItems and others, rule is lastSelected', () => {
+    const mod3x2 = {
+      _id: '68069a18766f8687858461e7',
+      name: '3x2',
+      properties: {},
+      type: 'discount',
+      tags: ['default'],
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'itemSet',
+            value: { itemSet: '3', itemRule: 'lastSelected' },
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 100,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 3,
+    };
+
+    const item2 = {
+      _id: 'bcd',
+      price: 10,
+      quantity: 3,
+    };
+
+    let order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+
+    order = pricingService.order.addItem({
+      order,
+      item,
+    }).updatedOrder;
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+
+    order = pricingService.order.addItem({
+      order,
+      item: item2,
+    }).updatedOrder;
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier: mod3x2,
+      itemIndex: 0,
+    });
+
+    expect(order.items.length).toEqual(2);
+
+    order = pricingService.order.calculate(order);
+
+    expect(order.total).toBe(40);
+    expect(order.items[0].total).toBe(20);
+    expect(order.items[0].modifiers.length).toBe(1);
+    expect(order.items[1].total).toBe(20);
+    expect(order.items[1].modifiers.length).toBe(1);
+  });
 });

package/__TEST__/order/order.test.js

@@ -3700,7 +3700,7 @@ describe('Order actions', () => {
     expect(splittedOrders[1].items[0].quantity).toEqual(6);
   });
 
-  test('CU-86dve295v Should continue to add a modifier while its quantity is less than the specified in properties.limits.maxAppliesOrder=5', () => {
+  test('CU-86dve295v Should add a modifier just once at order level even if  properties.limits.maxOrderUse=5', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -3715,7 +3715,7 @@ describe('Order actions', () => {
       },
       modifierId: 'abc123',
       properties: {
-        limits: { maxAppliesOrder: 5 },
+        limits: { maxOrderUse: 5 },
       },
     };
     order.items.push({
@@ -3734,10 +3734,10 @@ describe('Order actions', () => {
       });
     }
 
-    expect(currentOrder.modifiers.length).toBe(5);
+    expect(currentOrder.modifiers.length).toBe(1);
   });
 
-  test('CU-86dve295v Should continue to add a modifier if properties.limits.isUnlimitedAppliesOrder=true', () => {
+  test('CU-86dve295v Should add the modifier just once at order level even if  properties.limits.maxOrderUse=-1', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -3752,7 +3752,7 @@ describe('Order actions', () => {
       },
       modifierId: 'abc123',
       properties: {
-        limits: { isUnlimitedAppliesOrder: true },
+        limits: { maxOrderUse: -1 },
       },
     };
     order.items.push({
@@ -3771,10 +3771,10 @@ describe('Order actions', () => {
       });
     }
 
-    expect(currentOrder.modifiers.length).toBe(5);
+    expect(currentOrder.modifiers.length).toBe(1);
   });
 
-  test('CU-86dve295v Should not add a modifier more than once if properties.limits.isUnlimitedAppliesOrder=false and properties.limits.maxAppliesOrder is not defined', () => {
+  test('CU-86dve295v Should not add a modifier more than once if properties.limits.maxOrderUse is not defined', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -3789,7 +3789,7 @@ describe('Order actions', () => {
       },
       modifierId: 'abc123',
       properties: {
-        limits: { isUnlimitedAppliesOrder: false, maxAppliesOrder: 0 },
+        limits: { maxOrderUse: 0 },
       },
     };
     order.items.push({
@@ -3810,4 +3810,57 @@ describe('Order actions', () => {
 
     expect(currentOrder.modifiers.length).toBe(1);
   });
+
+  test('CU-86dve295v Should add to modifiers at order level', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      modifierId: 'abc123',
+      properties: {
+        limits: { maxOrderUse: 0 },
+      },
+    };
+
+    const modifier2 = {
+      _id: 2,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      modifierId: 'abc123',
+    };
+
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 5; i += 1) {
+      currentOrder = pricingService.order.addModifier({
+        order: currentOrder,
+        modifier,
+      });
+    }
+
+    currentOrder = pricingService.order.addModifier({
+      order: currentOrder,
+      modifier: modifier2,
+    });
+
+    expect(currentOrder.modifiers.length).toBe(2);
+  });
 });

package/lib/item/adjustCreditModifiersDifference.js

@@ -0,0 +1,34 @@
+module.exports = ({ utils, actions, modifierActions }) => {
+  const { math } = utils;
+
+  return function adjustCreditModifiersDifference({ subItems, difference }) {
+    const selectedSubItemIndex = subItems.findIndex(
+      subItem =>
+        modifierActions.hasCreditModifier(subItem.modifiers) &&
+        !actions.isFullyPaid(subItem) &&
+        subItem.total > difference
+    );
+
+    if (selectedSubItemIndex !== -1) {
+      const subItemToUpdate = {
+        ...subItems[selectedSubItemIndex],
+      };
+      const modifierToUpdateIdx = subItemToUpdate.modifiers.findIndex(
+        mod => mod.type === 'credit'
+      );
+      const prevAmount =
+        subItemToUpdate.modifiers[modifierToUpdateIdx].properties.maxAmount;
+
+      subItemToUpdate.modifiers[modifierToUpdateIdx].properties.maxAmount =
+        math.add(prevAmount, difference);
+
+      subItems.splice(
+        selectedSubItemIndex,
+        1,
+        actions.calculate(subItemToUpdate)
+      );
+    }
+
+    return subItems;
+  };
+};

package/lib/item/adjustFixedModifiersDifference.js

@@ -0,0 +1,37 @@
+module.exports = ({ utils, actions, modifierActions, _ }) => {
+  const { math } = utils;
+  const { getComputeModField } = require('../modifier/utils');
+  return function adjustFixedModifiersDifference({ subItems, difference }) {
+    const selectedSubItemIndex = subItems.findIndex(
+      subItem =>
+        modifierActions.hasFixedModifier(subItem.modifiers) &&
+        !actions.isFullyPaid(subItem) &&
+        subItem.total > difference
+    );
+
+    if (selectedSubItemIndex !== -1) {
+      const subItemToUpdate = {
+        ...subItems[selectedSubItemIndex],
+      };
+
+      const modifierToUpdateIdx = subItemToUpdate.modifiers.findIndex(
+        mod => mod.compute && mod.compute.type === 'fixed'
+      );
+      const prevCompute = getComputeModField(
+        subItemToUpdate.modifiers[modifierToUpdateIdx]
+      );
+      const prevAmount = _.get(prevCompute, 'compute.amount', 0);
+      if (modifierToUpdateIdx !== -1) {
+        subItemToUpdate.modifiers[modifierToUpdateIdx].compute.amount =
+          math.add(prevAmount, difference);
+      }
+      subItems.splice(
+        selectedSubItemIndex,
+        1,
+        actions.calculate(subItemToUpdate)
+      );
+    }
+
+    return subItems;
+  };
+};

package/lib/item/getItemsTotals.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-restricted-syntax */
 
-module.exports = ({ utils }) => {
+module.exports = ({ utils, actions }) => {
   const { math } = utils;
   return function getItemsTotals(items) {
     const subTotals = {};
@@ -8,7 +8,7 @@ module.exports = ({ utils }) => {
     let total = 0;
 
     for (const item of items) {
-      subTotal = math.add(subTotal, item.subTotals._actual);
+      subTotal = math.add(subTotal, actions.getSubtotal(item));
       const keys = Object.keys(item.subTotals).filter(
         key => !key.includes('_')
       );

package/lib/item/getModifierTags.js

@@ -8,7 +8,7 @@ module.exports = ({ modifierActions, settings }) =>
     let modifierTags = item.modifiers
       .filter(
         each =>
-          (modifierActions.isValid(each) || modifierActions.isItemSet(each)) &&
+          modifierActions.isValid(each) &&
           (!modifierActions.isGroup(each) || modifierActions.isDepartment(each))
       )
 

package/lib/item/getSubtotal.js

@@ -0,0 +1,5 @@
+module.exports = () =>
+  function getSubtotal(item) {
+    if (!item || !item.subTotals) return 0;
+    return item.subTotals._actual || 0;
+  };

package/lib/item/index.js

@@ -52,6 +52,13 @@ const getAddModifiers = require('./getAddModifiers');
 const getRelatedItems = require('./getRelatedItems');
 const getRelatedModifiers = require('./getRelatedModifiers');
 const unpickItem = require('./unpick');
+const spreadModifiers = require('./spreadModifiers');
+const splitAndCalculate = require('./splitAndCalculate');
+const validateFixedModifiersTotal = require('./validateFixedModifiersTotal');
+const adjustFixedModifiersDifference = require('./adjustFixedModifiersDifference');
+const validateCreditModifiersTotal = require('./validateCreditModifiersTotal');
+const adjustCreditModifiersDifference = require('./adjustCreditModifiersDifference');
+const getSubtotal = require('./getSubtotal');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -117,6 +124,13 @@ const itemActions = (deps = {}) => {
     getRelatedItems: getRelatedItems(innerDeps),
     getRelatedModifiers: getRelatedModifiers(innerDeps),
     unpickItem: unpickItem(innerDeps),
+    spreadModifiers: spreadModifiers(innerDeps),
+    splitAndCalculate: splitAndCalculate(innerDeps),
+    validateFixedModifiersTotal: validateFixedModifiersTotal(innerDeps),
+    adjustFixedModifiersDifference: adjustFixedModifiersDifference(innerDeps),
+    validateCreditModifiersTotal: validateCreditModifiersTotal(innerDeps),
+    adjustCreditModifiersDifference: adjustCreditModifiersDifference(innerDeps),
+    getSubtotal: getSubtotal(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/removeModifiersByQuantity.js

@@ -1,4 +1,4 @@
-module.exports = ({ modifierActions }) =>
+module.exports = ({ modifierActions, utils }) =>
   function removeModifiersByQuantity(item) {
     if (!item || !Array.isArray(item.modifiers)) {
       return item;
@@ -15,14 +15,15 @@ module.exports = ({ modifierActions }) =>
           modifierActions.isGroupOfModifiers(modifier) ||
           !modifier.modifierId ||
           !modifierActions.isDirect(modifier) ||
-          modifierActions.isUnlimitedAppliesItem(modifier)
+          modifierActions.isUnlimitedItemUse(modifier)
         )
           return true;
 
         const count = modifierCounts[modifier.modifierId] || 0;
 
-        const maxApplies = modifierActions.getMaxAppliesItem(modifier);
-        const maxQuantity = maxApplies || item.quantity;
+        const maxApplies = modifierActions.getMaxItemUse(modifier) || 0;
+        const maxQuantity =
+          utils.math.mul(item.quantity || 0, maxApplies) || item.quantity;
 
         if (count < maxQuantity) {
           modifierCounts[modifier.modifierId] = count + 1;

package/lib/item/splitAndCalculate.js

@@ -0,0 +1,18 @@
+module.exports = ({ actions, modifierActions }) =>
+  function splitAndCalculate({ parentItem, subItems }) {
+    if (!parentItem || !Array.isArray(subItems)) return [];
+    return subItems.map(each => {
+      const subTotal = actions.getSubtotal(actions.calculate(each));
+      const parentSubTotal = actions.getSubtotal(parentItem);
+
+      const newItem = {
+        ...each,
+        modifiers: modifierActions.getSplittedModifiers(
+          parentItem.modifiers,
+          parentSubTotal,
+          subTotal
+        ),
+      };
+      return actions.calculate(newItem);
+    });
+  };

package/lib/item/spreadModifiers.js

@@ -0,0 +1,21 @@
+module.exports = ({ actions }) =>
+  function spreadModifiers({ parentItem, subItems }) {
+    let subItemsWithCalculatedModifiers = actions.splitAndCalculate({
+      parentItem,
+      subItems,
+    });
+
+    // Validation
+
+    subItemsWithCalculatedModifiers = actions.validateFixedModifiersTotal({
+      parentItem,
+      subItems: [...subItemsWithCalculatedModifiers],
+    });
+
+    subItemsWithCalculatedModifiers = actions.validateCreditModifiersTotal({
+      parentItem,
+      subItems: [...subItemsWithCalculatedModifiers],
+    });
+
+    return subItemsWithCalculatedModifiers;
+  };

package/lib/item/validateCreditModifiersTotal.js

@@ -0,0 +1,23 @@
+module.exports = ({ utils, actions, modifierActions }) => {
+  const { math } = utils;
+
+  return function validateCreditModifiersTotal({ parentItem, subItems }) {
+    const creditModifiersTotalAmount = modifierActions.getCreditModifiersTotal(
+      parentItem.modifiers
+    );
+    const subItemsCreditModifiersTotalAmount =
+      modifierActions.getCreditModifiersTotalEntities(subItems);
+
+    if (creditModifiersTotalAmount !== subItemsCreditModifiersTotalAmount) {
+      return actions.adjustCreditModifiersDifference({
+        subItems: [...subItems],
+        difference: math.sub(
+          creditModifiersTotalAmount,
+          subItemsCreditModifiersTotalAmount
+        ),
+      });
+    }
+
+    return subItems;
+  };
+};

package/lib/item/validateFixedModifiersTotal.js

@@ -0,0 +1,23 @@
+module.exports = ({ utils, actions, modifierActions }) => {
+  const { math } = utils;
+
+  return function validateFixedModifiersTotal({ parentItem, subItems }) {
+    const fixedModifiersTotalAmount = modifierActions.getFixedModifiersTotal(
+      parentItem.modifiers
+    );
+    const subItemsFixedModifiersTotalAmount =
+      modifierActions.getFixedModifiersTotalEntities(subItems);
+
+    if (fixedModifiersTotalAmount !== subItemsFixedModifiersTotalAmount) {
+      return actions.adjustFixedModifiersDifference({
+        subItems: [...subItems],
+        difference: math.sub(
+          fixedModifiersTotalAmount,
+          subItemsFixedModifiersTotalAmount
+        ),
+      });
+    }
+
+    return subItems;
+  };
+};

package/lib/modifier/areConditionsMet.js

@@ -32,29 +32,33 @@ module.exports = ({ actions, utils }) => {
                   }
                 });
 
-              const itemIndexInSorted = matchingItems.findIndex(
+              let totalItemsLength = 0;
+
+              matchingItems.forEach(matchItem => {
+                totalItemsLength += matchItem.quantity || 0;
+              });
+
+              const itemIndex = matchingItems.findIndex(
                 entry => entry._id === item._id
               );
 
-              const itemSet =
-                itemIndexInSorted >= 0 ? itemIndexInSorted + 1 : null;
-
-              const matchingItemsLength = matchingItems.length;
+              const itemSetIndex = itemIndex >= 0 ? itemIndex + 1 : null;
 
               if (
                 condition.operand === '$eq' &&
                 conditionValue &&
-                matchingItemsLength >= conditionValue
+                totalItemsLength >= conditionValue
               ) {
                 const result = Math.floor(
-                  utils.math.div(matchingItemsLength, conditionValue)
+                  utils.math.div(totalItemsLength, conditionValue)
                 );
-                if (itemSet <= result) {
+
+                if (itemSetIndex <= result) {
                   return true;
                 }
               }
               return actions.validateItemNumber(
-                itemSet,
+                itemSetIndex,
                 conditionValue,
                 condition.operand
               );
@@ -101,7 +105,6 @@ module.exports = ({ actions, utils }) => {
       startRequestDate = null,
       allItems = null,
     } = opts;
-    // const recommendedEndDate = storeActions.getRecommendedEndDate();
     return (
       modifier &&
       modifierConditionPass(modifier, {

package/lib/modifier/getCreditModifiersTotalEntities.js

@@ -0,0 +1,12 @@
+module.exports = ({ utils, actions }) => {
+  const { math } = utils;
+
+  return function getCreditModifiersTotalEntities(entities) {
+    if (!Array.isArray(entities)) return 0;
+    return entities.reduce(
+      (acc, subEntity) =>
+        math.add(acc, actions.getCreditModifiersTotal(subEntity.modifiers)),
+      0
+    );
+  };
+};

package/lib/modifier/getFixedModifiersTotalEntities.js

@@ -0,0 +1,12 @@
+module.exports = ({ utils, actions }) => {
+  const { math } = utils;
+
+  return function getFixedModifiersTotalEntities(entities) {
+    if (!Array.isArray(entities)) return 0;
+    return entities.reduce(
+      (acc, subEntity) =>
+        math.add(acc, actions.getFixedModifiersTotal(subEntity.modifiers)),
+      0
+    );
+  };
+};

package/lib/modifier/getMaxItemQuantity.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getMaxItemQuantity(modifier) {
+    if (!actions.isLimits(modifier)) return 0;
+    return modifier.properties.limits.maxItemQuantity;
+  };

package/lib/modifier/getMaxItemUse.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getMaxItemUse(modifier) {
+    if (!actions.isLimits(modifier)) return 0;
+    return modifier.properties.limits.maxItemUse;
+  };

package/lib/modifier/getMaxOrderUse.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function getMaxOrderUse(modifier) {
+    if (!actions.isLimits(modifier)) return 0;
+    return modifier.properties.limits.maxOrderUse;
+  };