@darkpos/pricing 1.0.13 → 1.0.14

package/lib/modifier/getCreditModifiersTotal.js

@@ -0,0 +1,14 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+
+  return function getCreditModifiersTotal(modifiers) {
+    if (!Array.isArray(modifiers)) return 0;
+
+    const creditModifiers = modifiers.filter(mod => mod.type === 'credit');
+
+    return creditModifiers.reduce(
+      (acc, modifier) => math.add(acc, modifier.properties.maxAmount || 0),
+      0
+    );
+  };
+};

package/lib/modifier/getFixedModifiersTotal.js

@@ -0,0 +1,16 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+
+  return function getFixedModifiersTotal(modifiers) {
+    if (!Array.isArray(modifiers)) return 0;
+
+    const fixedModifiers = modifiers.filter(
+      mod => mod.compute.type === 'fixed'
+    );
+
+    return fixedModifiers.reduce(
+      (acc, modifier) => math.add(acc, modifier.compute.amount || 0),
+      0
+    );
+  };
+};

package/lib/modifier/getSplittedModifiers.js

@@ -1,5 +1,61 @@
 module.exports = ({ utils }) => {
   const { math, helpers } = utils;
+
+  const divideModifierAmount = ({
+    totalOriginOrder,
+    modifierAmount,
+    totalSplitedOrder,
+  }) =>
+    totalOriginOrder
+      ? math.div(
+        math.mul(modifierAmount, totalSplitedOrder || 0),
+        totalOriginOrder
+      )
+      : 0;
+
+  const splitCreditModifier = ({
+    modifier,
+    totalOriginOrder,
+    totalSplitedOrder,
+  }) => {
+    const maxAmount = divideModifierAmount({
+      modifierAmount: modifier.properties.maxAmount,
+      totalOriginOrder,
+      totalSplitedOrder,
+    });
+    return {
+      ...modifier,
+      compute: {
+        ...modifier.compute,
+        _id: helpers.getObjectID(),
+      },
+      properties: {
+        ...modifier.properties,
+        maxAmount,
+      },
+    };
+  };
+
+  const splitFixedModifier = ({
+    modifier,
+    totalOriginOrder,
+    totalSplitedOrder,
+  }) => {
+    const amount = divideModifierAmount({
+      modifierAmount: modifier.compute.amount,
+      totalOriginOrder,
+      totalSplitedOrder,
+    });
+    return {
+      ...modifier,
+      compute: {
+        ...modifier.compute,
+        _id: helpers.getObjectID(),
+        amount,
+      },
+    };
+  };
+
   return function getSplittedModifiers(
     modifiers,
     totalOriginOrder,
@@ -7,22 +63,25 @@ module.exports = ({ utils }) => {
   ) {
     return modifiers.map(each => {
       const modifier = { ...each };
-      const { compute = {} } = modifier;
-      if (compute.type === 'fixed' && compute.amount) {
-        const amount = totalOriginOrder
-          ? math.div(
-              math.mul(compute.amount, totalSplitedOrder || 0),
-              totalOriginOrder
-            )
-          : 0;
-        return {
-          ...modifier,
-          _id: helpers.getObjectID(),
-          compute: {
-            ...compute,
-            amount,
-          },
-        };
+
+      if (modifier.type === 'credit') {
+        return splitCreditModifier({
+          modifier,
+          totalOriginOrder,
+          totalSplitedOrder,
+        });
+      }
+
+      if (
+        modifier.compute &&
+        modifier.compute.type === 'fixed' &&
+        modifier.compute.amount
+      ) {
+        return splitFixedModifier({
+          modifier,
+          totalOriginOrder,
+          totalSplitedOrder,
+        });
       }
       return modifier;
     });

package/lib/modifier/hasCreditModifier.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function hasFixedModifier(modifiers) {
+    return modifiers.some(mod => mod.type === 'credit');
+  };

package/lib/modifier/hasFixedModifier.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function hasFixedModifier(modifiers) {
+    return modifiers.some(mod => mod.compute && mod.compute.type === 'fixed');
+  };

package/lib/modifier/index.js

@@ -61,6 +61,8 @@ const getSplittedModifiers = require('./getSplittedModifiers');
 const getSuggestion = require('./getSuggestion');
 const getUnhiddenModifiers = require('./getUnhiddenModifiers');
 const getUsingCount = require('./getUsingCount');
+const getFixedModifiersTotal = require('./getFixedModifiersTotal');
+const getCreditModifiersTotal = require('./getCreditModifiersTotal');
 const hasAddModifiers = require('./hasAddModifiers');
 const hasAllTag = require('./hasAllTag');
 const hasAttribute = require('./hasAttribute');
@@ -70,6 +72,8 @@ const hasDisplayPrompt = require('./hasDisplayPrompt');
 const hasMatchTags = require('./hasMatchTags');
 const hasModifier = require('./hasModifier');
 const hasRelatedItems = require('./hasRelatedItems');
+const hasFixedModifier = require('./hasFixedModifier');
+const hasCreditModifier = require('./hasCreditModifier');
 const includePiecesInQuantity = require('./includePiecesInQuantity');
 const includesInGroup = require('./includesInGroup');
 const isTrackUsageSubscription = require('./isTrackUsageSubscription');
@@ -184,6 +188,8 @@ const modifierActions = (deps = {}) => {
     getSuggestion: getSuggestion(innerDeps),
     getUnhiddenModifiers: getUnhiddenModifiers(innerDeps),
     getUsingCount: getUsingCount(innerDeps),
+    getFixedModifiersTotal: getFixedModifiersTotal(innerDeps),
+    getCreditModifiersTotal: getCreditModifiersTotal(innerDeps),
     hasAddModifiers: hasAddModifiers(innerDeps),
     hasAllTag: hasAllTag(innerDeps),
     hasNoTags: hasNoTags(innerDeps),
@@ -194,6 +200,8 @@ const modifierActions = (deps = {}) => {
     hasRelatedItems: hasRelatedItems(innerDeps),
     hasAttribute: hasAttribute(innerDeps),
     hasAttributes: hasAttributes(innerDeps),
+    hasFixedModifier: hasFixedModifier(innerDeps),
+    hasCreditModifier: hasCreditModifier(innerDeps),
     includePiecesInQuantity: includePiecesInQuantity(innerDeps),
     includesInGroup: includesInGroup(innerDeps),
     isTrackUsageSubscription: isTrackUsageSubscription(innerDeps),

package/lib/order/adjustCreditModifiersDifference.js

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

package/lib/order/adjustFixedModifiersDifference.js

@@ -0,0 +1,36 @@
+module.exports = ({ utils, actions, modifierActions }) => {
+  const { math } = utils;
+
+  return function adjustFixedModifiersDifference({ subOrders, difference }) {
+    const selectedSubOrderIndex = subOrders.findIndex(
+      subOrder =>
+        modifierActions.hasFixedModifier(subOrder.modifiers) &&
+        actions.isOpen(subOrder) &&
+        subOrder.total > difference
+    );
+
+    if (selectedSubOrderIndex !== -1) {
+      const subOrderToUpdate = {
+        ...subOrders[selectedSubOrderIndex],
+      };
+
+      const modifierToUpdateIdx = subOrderToUpdate.modifiers.findIndex(
+        mod => mod.compute.type === 'fixed'
+      );
+      const prevAmount =
+        subOrderToUpdate.modifiers[modifierToUpdateIdx].compute.amount;
+
+      subOrderToUpdate.modifiers[modifierToUpdateIdx].compute.amount = math.add(
+        prevAmount,
+        difference
+      );
+      subOrders.splice(
+        selectedSubOrderIndex,
+        1,
+        actions.calculate(subOrderToUpdate)
+      );
+    }
+
+    return subOrders;
+  };
+};

package/lib/order/getCreditModifiersTotal.js

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,15 @@
+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
+    );
+  };
+};

package/lib/order/index.js

@@ -72,6 +72,14 @@ const getScheduleByCustomer = require('./getScheduleByCustomer');
 const pickEndDate = require('./pickEndDate');
 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');
+const validateFixedModifiersTotal = require('./validateFixedModifiersTotal');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -156,6 +164,14 @@ const orderActions = (deps = {}) => {
     pickEndDate: pickEndDate(innerDeps),
     getAppliedCredit: getAppliedCredit(innerDeps),
     addCreditModifier: addCreditModifier(innerDeps),
+    adjustCreditModifiersDifference: adjustCreditModifiersDifference(innerDeps),
+    adjustFixedModifiersDifference: adjustFixedModifiersDifference(innerDeps),
+    getCreditModifiersTotal: getCreditModifiersTotal(innerDeps),
+    getFixedModifiersTotal: getFixedModifiersTotal(innerDeps),
+    splitAndCalculate: splitAndCalculate(innerDeps),
+    spreadModifiers: spreadModifiers(innerDeps),
+    validateCreditModifiersTotal: validateCreditModifiersTotal(innerDeps),
+    validateFixedModifiersTotal: validateFixedModifiersTotal(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/splitAndCalculate.js

@@ -0,0 +1,16 @@
+module.exports = ({ actions, modifierActions }) =>
+  function splitAndCalculate({ parentOrder, subOrders }) {
+    if (!parentOrder || !Array.isArray(subOrders)) return [];
+    return subOrders.map(each => {
+      const { subTotal } = actions.calculate(each);
+      const newOrder = {
+        ...each,
+        modifiers: modifierActions.getSplittedModifiers(
+          parentOrder.modifiers,
+          parentOrder.subTotal,
+          subTotal
+        ),
+      };
+      return actions.calculate(newOrder);
+    });
+  };

package/lib/order/splitByDepartments.js

@@ -1,13 +1,13 @@
 module.exports = ({
   utils,
   _,
+  actions,
   itemActions,
   modifierActions,
-  actions,
   settings,
 }) => {
   const orderSettings = _.get(settings, 'order');
-  const { date, math, helpers } = utils;
+  const { date, helpers } = utils;
   const noteDefaults = {
     message: '',
     attributes: [],
@@ -17,25 +17,6 @@ module.exports = ({
     __typename: 'Note',
   };
 
-  const getSplitModifiers = (modifiers, totalOriginOrder, totalSplitedOrder) =>
-    modifiers.map(each => {
-      const modifier = { ...each };
-      if (modifier.type === 'fixed' && modifier.amount) {
-        const amount = totalOriginOrder
-          ? math.div(
-              math.mul(modifier.amount, totalSplitedOrder || 0),
-              totalOriginOrder
-            )
-          : 0;
-        return {
-          ...modifier,
-          _id: helpers.getObjectID(),
-          amount,
-        };
-      }
-      return modifier;
-    });
-
   const joinItemQuantity = orders =>
     orders.map(order => {
       const items = order.items.reduce((arr, item) => {
@@ -67,29 +48,29 @@ module.exports = ({
 
   const getOrder =
     ({ order, name }) =>
-    (items, index) => {
-      let displayId = '';
-      if (orderSettings.allowSuborder)
-        displayId = `${order.displayId}-${index}`;
-      else if (index === 1) displayId = order.displayId;
-      return {
-        ...order,
-        _id: helpers.getObjectID(),
-        displayId,
-        discount: 0,
-        tax: 0,
-        parentId: orderSettings.allowSuborder ? order._id : null,
-        items,
-        modifiers: [],
-        notes: [
-          ...(order.notes || []),
-          {
-            ...noteDefaults,
-            message: `Split from ${order.displayId}, for department ${name}`,
-          },
-        ],
+      (items, index) => {
+        let displayId = '';
+        if (orderSettings.allowSuborder)
+          displayId = `${order.displayId}-${index}`;
+        else if (index === 1) displayId = order.displayId;
+        return {
+          ...order,
+          _id: helpers.getObjectID(),
+          displayId,
+          discount: 0,
+          tax: 0,
+          parentId: orderSettings.allowSuborder ? order._id : null,
+          items,
+          modifiers: [],
+          notes: [
+            ...(order.notes || []),
+            {
+              ...noteDefaults,
+              message: `Split from ${order.displayId}, for department ${name}`,
+            },
+          ],
+        };
       };
-    };
 
   const getDepartmentName = item => {
     const deps = itemActions.getDepartmentModifiers(item);
@@ -127,7 +108,7 @@ module.exports = ({
               newOrder =>
                 newOrder.items &&
                 itemActions.getItemsTotalPieces(newOrder.items) + totalPieces <=
-                  maxItems &&
+                maxItems &&
                 departmentName === getDepartmentName(newOrder.items[0])
             );
             if (index > -1) splitOrders[index].items.push(item);
@@ -139,13 +120,11 @@ module.exports = ({
 
     splitOrders = joinItemQuantity(splitOrders);
 
-    return splitOrders.map(each => {
-      const { subTotal } = actions.calculate(each);
-      const newOrder = {
-        ...each,
-        modifiers: getSplitModifiers(order.modifiers, order.subTotal, subTotal),
-      };
-      return actions.calculate(newOrder);
+    splitOrders = actions.spreadModifiers({
+      parentOrder: order,
+      subOrders: splitOrders,
     });
+
+    return splitOrders;
   };
 };

package/lib/order/spreadModifiers.js

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

package/lib/order/validateCreditModifiersTotal.js

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

package/lib/order/validateFixedModifiersTotal.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -35,5 +35,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "e70158333e19e0d6106cb2db4efe0a25842c323b"
+  "gitHead": "67ed395c1d86589b37c5adcb74606a8db7423536"
 }