@darkpos/pricing 1.0.80 → 1.0.81

package/__TEST__/modifier.test.js

@@ -1,6 +1,12 @@
 const usePricing = require('../index');
 
-const pricingService = usePricing();
+const mockStores = require('./mocks/stores');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
 
 describe('Modifier actions', () => {
   test('CU-86dv8hzxg modifier.isGroup fn', () => {
@@ -1334,4 +1340,331 @@ describe('Modifier actions', () => {
     expect(error).toEqual('modifier.has.reached.the.maximum.amount.of.applies');
     expect(currentOrder.items[3].modifiers.length).toBe(0);
   });
+  test('CU-86dve295v should split item based on modifier.maxItemQuantity', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        limits: { maxItemQuantity: 1 },
+      },
+      modifierId: 'aaa',
+    };
+
+    order.items.push({
+      quantity: 10,
+      itemId: '111',
+      price: 100,
+      modifiers: [],
+    });
+
+    let currentOrder = { ...order };
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 0,
+    });
+
+    expect(currentOrder.items.length).toEqual(1);
+
+    currentOrder = pricingService.order.splitItems({
+      order: currentOrder,
+    });
+
+    expect(currentOrder.items.length).toEqual(10);
+  });
+
+  test('CU-86dve295v should split item based on modifier.maxItemQuantity, and spread modifiers accordingly 1', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        limits: { maxItemQuantity: 1 },
+      },
+      modifierId: 'aaa',
+    };
+
+    let currentOrder = { ...order };
+
+    currentOrder = pricingService.order.addItem({
+      order,
+      item: {
+        quantity: 10,
+        itemId: '111',
+        price: 100,
+        modifiers: [],
+        subTotals: {},
+      },
+    }).updatedOrder;
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 0,
+    });
+
+    expect(currentOrder.items.length).toEqual(1);
+
+    currentOrder = pricingService.order.calculate(currentOrder);
+
+    currentOrder = pricingService.order.splitItems({
+      order: currentOrder,
+    });
+
+    expect(currentOrder.items.length).toEqual(10);
+    expect(currentOrder.total).toEqual(990);
+
+    expect(currentOrder.items[0].total).toEqual(99);
+    expect(currentOrder.items[0].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[1].total).toEqual(99);
+    expect(currentOrder.items[1].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[2].total).toEqual(99);
+    expect(currentOrder.items[2].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[3].total).toEqual(99);
+    expect(currentOrder.items[3].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[4].total).toEqual(99);
+    expect(currentOrder.items[4].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[5].total).toEqual(99);
+    expect(currentOrder.items[5].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[6].total).toEqual(99);
+    expect(currentOrder.items[6].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[7].total).toEqual(99);
+    expect(currentOrder.items[7].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[8].total).toEqual(99);
+    expect(currentOrder.items[8].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[9].total).toEqual(99);
+    expect(currentOrder.items[9].modifiers[0]._computed.amount).toEqual(-1);
+  });
+
+  test('CU-86dve295v should split item based on modifier.maxItemQuantity=2, and spread modifiers accordingly 2', () => {
+    const order = {
+      id: 'ord-456',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 2,
+      compute: {
+        amount: 5,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        limits: { maxItemQuantity: 2 },
+      },
+      modifierId: 'bbb',
+    };
+
+    let currentOrder = { ...order };
+
+    currentOrder = pricingService.order.addItem({
+      order,
+      item: {
+        quantity: 8,
+        itemId: '222',
+        price: 50,
+        modifiers: [],
+        subTotals: {},
+      },
+    }).updatedOrder;
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 0,
+    });
+
+    currentOrder = pricingService.order.calculate(currentOrder);
+
+    expect(currentOrder.items.length).toEqual(1);
+
+    expect(currentOrder.total).toEqual(395);
+
+    currentOrder = pricingService.order.splitItems({
+      order: currentOrder,
+    });
+
+    expect(currentOrder.items.length).toEqual(4);
+    expect(currentOrder.total).toEqual(395);
+
+    currentOrder.items.forEach(item => {
+      expect(item.quantity).toEqual(2);
+      expect(item.total).toEqual(98.75);
+      expect(item.modifiers[0]._computed.amount).toEqual(-1.25);
+    });
+  });
+
+  test('CU-86dve295v should split 1 item  and left other untouched.', () => {
+    const order = {
+      id: 'ord-456',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 2,
+      compute: {
+        amount: 5,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        limits: { maxItemQuantity: 2 },
+      },
+      modifierId: 'bbb',
+    };
+
+    const redModifier = {
+      _id: 3,
+      modifierId: 'red-ccc',
+      name: 'red',
+    };
+
+    let currentOrder = { ...order };
+
+    currentOrder = pricingService.order.addItem({
+      order,
+      item: {
+        quantity: 8,
+        itemId: '222',
+        price: 50,
+        modifiers: [],
+        subTotals: {},
+      },
+    }).updatedOrder;
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 0,
+    });
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier: redModifier,
+      itemIndex: 0,
+    });
+
+    currentOrder = pricingService.order.addItem({
+      order: currentOrder,
+      item: {
+        quantity: 1,
+        itemId: '333',
+        price: 100,
+        modifiers: [],
+        subTotals: {},
+      },
+    }).updatedOrder;
+
+    currentOrder = pricingService.order.calculate(currentOrder);
+
+    expect(currentOrder.items.length).toEqual(2);
+
+    expect(currentOrder.total).toEqual(495);
+
+    currentOrder = pricingService.order.splitItems({
+      order: currentOrder,
+    });
+
+    expect(currentOrder.items.length).toEqual(5);
+    expect(currentOrder.total).toEqual(495);
+
+    expect(currentOrder.items[0].total).toEqual(100);
+    expect(currentOrder.items[0].modifiers.length).toBe(0);
+
+    expect(currentOrder.items[1].total).toEqual(98.75);
+    expect(currentOrder.items[1].modifiers[0].name).toBe('red');
+    expect(currentOrder.items[1].modifiers[1]._computed.amount).toBe(-1.25);
+
+    expect(currentOrder.items[2].total).toEqual(98.75);
+    expect(currentOrder.items[2].modifiers[0].name).toBe('red');
+    expect(currentOrder.items[2].modifiers[1]._computed.amount).toBe(-1.25);
+
+    expect(currentOrder.items[3].total).toEqual(98.75);
+    expect(currentOrder.items[3].modifiers[0].name).toBe('red');
+    expect(currentOrder.items[3].modifiers[1]._computed.amount).toBe(-1.25);
+
+    expect(currentOrder.items[4].total).toEqual(98.75);
+    expect(currentOrder.items[4].modifiers[0].name).toBe('red');
+    expect(currentOrder.items[4].modifiers[1]._computed.amount).toBe(-1.25);
+  });
+
+  test('CU-86dve295v should split item based on modifier.maxItemQuantity=4, and spread modifiers accordingly', () => {
+    const order = {
+      id: 'ord-456',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 2,
+      compute: {
+        amount: 5,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        limits: { maxItemQuantity: 4 },
+      },
+      modifierId: 'bbb',
+    };
+
+    let currentOrder = { ...order };
+
+    currentOrder = pricingService.order.addItem({
+      order,
+      item: {
+        quantity: 10,
+        itemId: '222',
+        price: 50,
+        modifiers: [],
+        subTotals: {},
+      },
+    }).updatedOrder;
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 0,
+    });
+
+    currentOrder = pricingService.order.calculate(currentOrder);
+
+    expect(currentOrder.items.length).toEqual(1);
+
+    expect(currentOrder.total).toEqual(495);
+
+    currentOrder = pricingService.order.splitItems({
+      order: currentOrder,
+    });
+
+    expect(currentOrder.items.length).toEqual(3);
+
+    expect(currentOrder.items[0].quantity).toEqual(4);
+    expect(currentOrder.items[0].modifiers[0]._computed.amount).toEqual(-2);
+
+    expect(currentOrder.items[1].quantity).toEqual(4);
+    expect(currentOrder.items[1].modifiers[0]._computed.amount).toEqual(-2);
+
+    expect(currentOrder.items[2].quantity).toEqual(2);
+    expect(currentOrder.items[2].modifiers[0]._computed.amount).toEqual(-1);
+
+    expect(currentOrder.total).toEqual(495);
+  });
 });

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/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/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/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/getSplittedModifiers.js

@@ -3,28 +3,21 @@ module.exports = ({ utils }) => {
   const { getComputeModField } = require('./utils');
 
   const divideModifierAmount = ({
-    totalOriginOrder,
+    totalOrigin,
     modifierAmount,
-    totalSplitedOrder,
+    totalSplited,
   }) =>
-    totalOriginOrder
+    totalOrigin
       ? math.toDecimalPlaces(
-          math.div(
-            math.mul(modifierAmount, totalSplitedOrder || 0),
-            totalOriginOrder
-          )
+          math.div(math.mul(modifierAmount, totalSplited || 0), totalOrigin)
         )
       : 0;
 
-  const splitCreditModifier = ({
-    modifier,
-    totalOriginOrder,
-    totalSplitedOrder,
-  }) => {
+  const splitCreditModifier = ({ modifier, totalOrigin, totalSplited }) => {
     const maxAmount = divideModifierAmount({
       modifierAmount: modifier.properties.maxAmount,
-      totalOriginOrder,
-      totalSplitedOrder,
+      totalOrigin,
+      totalSplited,
     });
     const compute = getComputeModField(modifier);
     return {
@@ -39,15 +32,11 @@ module.exports = ({ utils }) => {
     };
   };
 
-  const splitFixedModifier = ({
-    modifier,
-    totalOriginOrder,
-    totalSplitedOrder,
-  }) => {
+  const splitFixedModifier = ({ modifier, totalOrigin, totalSplited }) => {
     const amount = divideModifierAmount({
       modifierAmount: modifier.compute.amount,
-      totalOriginOrder,
-      totalSplitedOrder,
+      totalOrigin,
+      totalSplited,
     });
     return {
       ...modifier,
@@ -58,27 +47,23 @@ module.exports = ({ utils }) => {
     };
   };
 
-  return function getSplittedModifiers(
-    modifiers,
-    totalOriginOrder,
-    totalSplitedOrder
-  ) {
+  return function getSplittedModifiers(modifiers, totalOrigin, totalSplited) {
     return modifiers.map(each => {
       const modifier = { ...each };
       const compute = getComputeModField(modifier);
       if (modifier.type === 'credit') {
         return splitCreditModifier({
           modifier,
-          totalOriginOrder,
-          totalSplitedOrder,
+          totalOrigin,
+          totalSplited,
         });
       }
 
       if (compute && compute.type === 'fixed' && compute.amount) {
         return splitFixedModifier({
           modifier,
-          totalOriginOrder,
-          totalSplitedOrder,
+          totalOrigin,
+          totalSplited,
         });
       }
       return modifier;

package/lib/modifier/index.js

@@ -54,6 +54,8 @@ const getSuggestion = require('./getSuggestion');
 const getUnhiddenModifiers = require('./getUnhiddenModifiers');
 const getUsingCount = require('./getUsingCount');
 const getFixedModifiersTotal = require('./getFixedModifiersTotal');
+const getFixedModifiersTotalEntities = require('./getFixedModifiersTotalEntities');
+const getCreditModifiersTotalEntities = require('./getCreditModifiersTotalEntities');
 const getCreditModifiersTotal = require('./getCreditModifiersTotal');
 const hasAddModifiers = require('./hasAddModifiers');
 const hasAllTag = require('./hasAllTag');
@@ -158,6 +160,7 @@ const validateItemNumber = require('./validateItemNumber');
 const isLimits = require('./isLimits');
 const isItemSet = require('./isItemSet');
 const isOrderUseValid = require('./isOrderUseValid');
+const getMaxItemQuantity = require('./getMaxItemQuantity');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -329,6 +332,9 @@ const modifierActions = (deps = {}) => {
     isLimits: isLimits(innerDeps),
     isItemSet: isItemSet(innerDeps),
     isOrderUseValid: isOrderUseValid(innerDeps),
+    getMaxItemQuantity: getMaxItemQuantity(innerDeps),
+    getFixedModifiersTotalEntities: getFixedModifiersTotalEntities(innerDeps),
+    getCreditModifiersTotalEntities: getCreditModifiersTotalEntities(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/index.js

@@ -73,8 +73,6 @@ const getAppliedCredit = require('./getAppliedCredit');
 const addCreditModifier = require('./addCreditModifier');
 const adjustCreditModifiersDifference = require('./adjustCreditModifiersDifference');
 const adjustFixedModifiersDifference = require('./adjustFixedModifiersDifference');
-const getCreditModifiersTotal = require('./getCreditModifiersTotal');
-const getFixedModifiersTotal = require('./getFixedModifiersTotal');
 const splitAndCalculate = require('./splitAndCalculate');
 const spreadModifiers = require('./spreadModifiers');
 const validateCreditModifiersTotal = require('./validateCreditModifiersTotal');
@@ -90,6 +88,7 @@ const getBalance = require('./getBalance');
 const getLastLocation = require('./getLastLocation');
 const getModifierRelations = require('./getModifierRelations');
 const resetItem = require('./resetItem');
+const splitItems = require('./splitItems');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -174,8 +173,6 @@ const orderActions = (deps = {}) => {
     addCreditModifier: addCreditModifier(innerDeps),
     adjustCreditModifiersDifference: adjustCreditModifiersDifference(innerDeps),
     adjustFixedModifiersDifference: adjustFixedModifiersDifference(innerDeps),
-    getCreditModifiersTotal: getCreditModifiersTotal(innerDeps),
-    getFixedModifiersTotal: getFixedModifiersTotal(innerDeps),
     splitAndCalculate: splitAndCalculate(innerDeps),
     spreadModifiers: spreadModifiers(innerDeps),
     validateCreditModifiersTotal: validateCreditModifiersTotal(innerDeps),
@@ -191,6 +188,7 @@ const orderActions = (deps = {}) => {
     getLastLocation: getLastLocation(innerDeps),
     getModifierRelations: getModifierRelations(innerDeps),
     resetItem: resetItem(innerDeps),
+    splitItems: splitItems(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/splitItems.js

@@ -0,0 +1,50 @@
+module.exports = ({ actions, modifierActions, itemActions }) =>
+  function splitItems({ order }) {
+    if (!order || !order.items) return order;
+
+    const newItems = [];
+    let shouldRecalculate = false;
+
+    order.items.forEach(item => {
+      if (!item.modifiers) {
+        newItems.push(item);
+        return;
+      }
+
+      const maxItemQuantityMod = item.modifiers.find(mod =>
+        modifierActions.getMaxItemQuantity(mod)
+      );
+
+      const maxQuantity =
+        modifierActions.getMaxItemQuantity(maxItemQuantityMod);
+
+      if (!maxQuantity || item.quantity <= maxQuantity) {
+        newItems.push(item);
+        return;
+      }
+
+      let remaining = item.quantity;
+      let spreadedItems = [];
+      while (remaining > 0) {
+        if (!shouldRecalculate) shouldRecalculate = true;
+        const splitQty = Math.min(remaining, maxQuantity);
+        spreadedItems.push({
+          ...item,
+          quantity: splitQty,
+          modifiers: [],
+        });
+        remaining -= splitQty;
+      }
+
+      spreadedItems = itemActions.spreadModifiers({
+        parentItem: item,
+        subItems: spreadedItems,
+      });
+
+      newItems.push(...spreadedItems);
+    });
+
+    return shouldRecalculate
+      ? actions.calculate({ ...order, items: newItems })
+      : order;
+  };

package/lib/order/validateCreditModifiersTotal.js

@@ -6,7 +6,7 @@ module.exports = ({ utils, actions, modifierActions }) => {
       parentOrder.modifiers
     );
     const subOrdersCreditModifiersTotalAmount =
-      actions.getCreditModifiersTotal(subOrders);
+      modifierActions.getCreditModifiersTotalEntities(subOrders);
 
     if (creditModifiersTotalAmount !== subOrdersCreditModifiersTotalAmount) {
       return actions.adjustCreditModifiersDifference({

package/lib/order/validateFixedModifiersTotal.js

@@ -6,7 +6,7 @@ module.exports = ({ utils, actions, modifierActions }) => {
       parentOrder.modifiers
     );
     const subOrdersFixedModifiersTotalAmount =
-      actions.getFixedModifiersTotal(subOrders);
+      modifierActions.getFixedModifiersTotalEntities(subOrders);
 
     if (fixedModifiersTotalAmount !== subOrdersFixedModifiersTotalAmount) {
       return actions.adjustFixedModifiersDifference({

package/package.json

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

package/lib/order/getCreditModifiersTotal.js

@@ -1,15 +0,0 @@
-module.exports = ({ utils, modifierActions }) => {
-  const { math } = utils;
-
-  return function getCreditModifiersTotal(orders) {
-    if (!Array.isArray(orders)) return 0;
-    return orders.reduce(
-      (acc, subOrder) =>
-        math.add(
-          acc,
-          modifierActions.getCreditModifiersTotal(subOrder.modifiers)
-        ),
-      0
-    );
-  };
-};

package/lib/order/getFixedModifiersTotal.js

@@ -1,15 +0,0 @@
-module.exports = ({ utils, modifierActions }) => {
-  const { math } = utils;
-
-  return function getFixedModifiersTotal(orders) {
-    if (!Array.isArray(orders)) return 0;
-    return orders.reduce(
-      (acc, subOrder) =>
-        math.add(
-          acc,
-          modifierActions.getFixedModifiersTotal(subOrder.modifiers)
-        ),
-      0
-    );
-  };
-};