@darkpos/pricing 1.0.31 → 1.0.33

package/lib/item/calculate.js

@@ -2,6 +2,8 @@
 module.exports = ({ _, utils, actions, modifierActions }) => {
   const { math } = utils;
   //
+  const { getComputeModField } = require('../modifier/utils');
+
   const calculateOne = inputItem => {
     const item = _.cloneDeep(inputItem);
     if (!item) return item;
@@ -70,8 +72,10 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         const computedAmountCalc = math.mul(_computed.amount, quantity);
         const computedPriceCalc = math.mul(computedPrice * quantity);
 
+        // adding this computeField because now the compute from a modifier can be null
+        const computeField = getComputeModField(_modifier);
         let computedAmount =
-          _modifier.compute.type === 'percentage' ||
+          computeField.type === 'percentage' ||
           modifierActions.isIgnoreQuantity(_modifier) ||
           (!modifierActions.isFixedAdd(_modifier) &&
             math.gt(math.abs(computedAmountCalc), computedPriceCalc))

package/lib/item/getItemsTotalQuantity.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function getItemsTotalPieces(items) {
+    return items.reduce(
+      (total, item) => total + actions.getTotalQuantity(item),
+      0
+    );
+  };

package/lib/item/getItemsTotalWeight.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function getItemsTotalWeight(items) {
+    return items.reduce(
+      (total, item) => total + actions.getTotalWeight(item),
+      0
+    );
+  };

package/lib/item/getTotalPieces.js

@@ -2,6 +2,6 @@ module.exports = ({ utils }) => {
   const { math } = utils;
   return function getTotalPieces(item) {
     if (!item) return 0;
-    return math.mul(item.quantity || 1, item.pieces || 1);
+    return math.mul(item.quantity || 0, item.pieces || 0);
   };
 };

package/lib/item/getTotalQuantity.js

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

package/lib/item/getTotalWeight.js

@@ -0,0 +1,7 @@
+module.exports = ({ utils }) => {
+  const { math } = utils;
+  return function getTotalWeight(item) {
+    if (!item) return 0;
+    return math.mul(item.quantity || 0, item.weight || 0);
+  };
+};

package/lib/item/index.js

@@ -1,5 +1,9 @@
 const getItemsTotalPieces = require('./getItemsTotalPieces');
 const getTotalPieces = require('./getTotalPieces');
+const getItemsTotalQuantity = require('./getItemsTotalQuantity');
+const getTotalQuantity = require('./getTotalQuantity');
+const getItemsTotalWeight = require('./getItemsTotalWeight');
+const getTotalWeight = require('./getTotalWeight');
 const removeModifier = require('./removeModifier');
 const removeModifiers = require('./removeModifiers');
 const findOriginalItem = require('./findOriginalItem');
@@ -45,6 +49,10 @@ const itemActions = (deps = {}) => {
   };
 
   const freezedActions = Object.freeze({
+    getItemsTotalWeight: getItemsTotalWeight(innerDeps),
+    getTotalWeight: getTotalWeight(innerDeps),
+    getItemsTotalQuantity: getItemsTotalQuantity(innerDeps),
+    getTotalQuantity: getTotalQuantity(innerDeps),
     getItemsTotalPieces: getItemsTotalPieces(innerDeps),
     getTotalPieces: getTotalPieces(innerDeps),
     removeModifier: removeModifier(innerDeps),

package/lib/modifier/calculate.js

@@ -1,3 +1,5 @@
+const { getComputeModField } = require('./utils');
+
 /**
  * Get calculated modifier
  */
@@ -9,8 +11,9 @@ module.exports = ({ _, constants, utils, localization, actions }) => {
     modifier = {},
     options = { price: 0, quantity: 0, skip: false }
   ) {
-    const { name, compute } = modifier;
-    const { type, action, amount = 0 } = compute || {};
+    const { name } = modifier;
+    const compute = getComputeModField(modifier);
+    const { type, action, amount = 0 } = compute;
     const _computed = {
       amount: 0,
       description: '',

package/lib/modifier/createIndirectModifier.js

@@ -4,15 +4,16 @@
 module.exports = ({ _, utils, constants, actions }) => {
   const { math } = utils;
   const { Modifier } = constants;
-
+  const { getComputeModField } = require('./utils');
   return function createIndirectModifier(
     modifier,
     options = { orderTotal: 0, itemQuantity: 1, itemTotal: 0 }
   ) {
     const maxAmount = actions.getProperty(modifier, 'maxAmount');
 
-    const compute = modifier.compute || {};
-    const { type, amount = 0 } = compute;
+    const compute = getComputeModField(modifier);
+    const type = _.get(compute, 'type', '');
+    const amount = _.get(compute, 'amount', 0);
     let modifierAmount = amount;
 
     if (type === Modifier.Compute.Types.PERCENTAGE) {

package/lib/modifier/getFixedModifiersTotal.js

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

package/lib/modifier/getSplittedModifiers.js

@@ -1,5 +1,6 @@
 module.exports = ({ utils }) => {
   const { math } = utils;
+  const { getComputeModField } = require('./utils');
 
   const divideModifierAmount = ({
     totalOriginOrder,
@@ -25,10 +26,11 @@ module.exports = ({ utils }) => {
       totalOriginOrder,
       totalSplitedOrder,
     });
+    const compute = getComputeModField(modifier);
     return {
       ...modifier,
       compute: {
-        ...modifier.compute,
+        ...compute,
       },
       properties: {
         ...modifier.properties,
@@ -63,7 +65,7 @@ module.exports = ({ utils }) => {
   ) {
     return modifiers.map(each => {
       const modifier = { ...each };
-
+      const compute = getComputeModField(modifier);
       if (modifier.type === 'credit') {
         return splitCreditModifier({
           modifier,
@@ -72,11 +74,7 @@ module.exports = ({ utils }) => {
         });
       }
 
-      if (
-        modifier.compute &&
-        modifier.compute.type === 'fixed' &&
-        modifier.compute.amount
-      ) {
+      if (compute && compute.type === 'fixed' && compute.amount) {
         return splitFixedModifier({
           modifier,
           totalOriginOrder,

package/lib/modifier/index.js

@@ -76,7 +76,6 @@ 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');
 const isDirect = require('./isDirect');
@@ -218,7 +217,6 @@ const modifierActions = (deps = {}) => {
     hasAttributes: hasAttributes(innerDeps),
     hasFixedModifier: hasFixedModifier(innerDeps),
     hasCreditModifier: hasCreditModifier(innerDeps),
-    includePiecesInQuantity: includePiecesInQuantity(innerDeps),
     includesInGroup: includesInGroup(innerDeps),
     isTrackUsageSubscription: isTrackUsageSubscription(innerDeps),
     isDirect: isDirect(innerDeps),

package/lib/modifier/isComputedOverride.js

@@ -1,7 +1,8 @@
-module.exports = ({ actions, constants }) => {
+module.exports = ({ constants }) => {
   const { Modifier } = constants;
   return function isComputedOverride(modifier) {
-    const computeAction = modifier && modifier.compute && modifier.compute.action;
+    const computeAction =
+      modifier && modifier.compute && modifier.compute.action;
     return computeAction === Modifier.Attributes.OVERRIDE;
   };
 };

package/lib/modifier/utils.js

@@ -0,0 +1,10 @@
+const _ = require('lodash');
+
+const getComputeModField = modifier =>
+  _.isNull(modifier.compute) || !modifier.compute
+    ? { type: '', amount: 0, action: '' }
+    : modifier.compute;
+
+module.exports = {
+  getComputeModField,
+};

package/lib/order/addItemModifier.js

@@ -1,9 +1,10 @@
 module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
   const { math } = utils;
+  const { getComputeModField } = require('../modifier/utils');
 
   const getPrice = ({ item, modifier }) => {
-    const amount =
-      (modifier && modifier.compute && modifier.compute.amount) || 0;
+    const compute = getComputeModField(modifier);
+    const amount = (modifier && compute && compute.amount) || 0;
     const { price = 0 } = item;
     if (modifierActions.isMultiplier(modifier)) return math.mul(price, amount);
     return amount;
@@ -64,6 +65,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     },
   }) => {
     let item = { ...itemProp };
+    const compute = getComputeModField(modifier);
     if (hasBehaivoralFields(modifier)) return item;
     // check conditions
     if (!areConditionsMet(item, modifier.conditions)) return item;
@@ -91,7 +93,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     if (modifierActions.isAmountOverride(modifier)) {
       item = {
         ...item,
-        price: modifier.compute.amount,
+        price: compute.amount,
       };
     }
 
@@ -99,7 +101,10 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
       item.quantity = modifier.compute.amount || 1;
     }
 
-    if (modifierActions.isPriceOverride(modifier) ||  modifierActions.isComputedOverride(modifier)) {
+    if (
+      modifierActions.isPriceOverride(modifier) ||
+      modifierActions.isComputedOverride(modifier)
+    ) {
       item.price = getPrice({ modifier, item });
     } else {
       item.price = itemActions.getItemPrice({

package/lib/order/addModifier.js

@@ -1,11 +1,12 @@
-module.exports = ({ actions, modifierActions }) =>
-  function addModifier({ order, modifier }) {
+module.exports = ({ actions, modifierActions }) => {
+  const { getComputeModField } = require('../modifier/utils');
+  return function addModifier({ order, modifier }) {
     if (!modifier) return order;
     const { modifiers = [] } = order;
-
     if (modifierActions.isFixedDiscount(modifier)) {
+      const compute = getComputeModField(modifier);
       const orderDue = actions.calculateDue(order);
-      if (modifier.compute.amount > orderDue) {
+      if (compute.amount > orderDue) {
         const err = new Error();
         err.valid = false;
         err.orderDue = orderDue;
@@ -19,3 +20,4 @@ module.exports = ({ actions, modifierActions }) =>
       modifiers: [...modifiers, { ...modifier }],
     };
   };
+};

package/lib/order/adjustFixedModifiersDifference.js

@@ -1,6 +1,6 @@
-module.exports = ({ utils, actions, modifierActions }) => {
+module.exports = ({ utils, actions, modifierActions, _ }) => {
   const { math } = utils;
-
+  const { getComputeModField } = require('../modifier/utils');
   return function adjustFixedModifiersDifference({ subOrders, difference }) {
     const selectedSubOrderIndex = subOrders.findIndex(
       subOrder =>
@@ -15,15 +15,16 @@ module.exports = ({ utils, actions, modifierActions }) => {
       };
 
       const modifierToUpdateIdx = subOrderToUpdate.modifiers.findIndex(
-        mod => mod.compute.type === 'fixed'
+        mod => mod.compute && mod.compute.type === 'fixed'
       );
-      const prevAmount =
-        subOrderToUpdate.modifiers[modifierToUpdateIdx].compute.amount;
-
-      subOrderToUpdate.modifiers[modifierToUpdateIdx].compute.amount = math.add(
-        prevAmount,
-        difference
+      const prevCompute = getComputeModField(
+        subOrderToUpdate.modifiers[modifierToUpdateIdx]
       );
+      const prevAmount = _.get(prevCompute, 'compute.amount', 0);
+      if (modifierToUpdateIdx !== -1) {
+        subOrderToUpdate.modifiers[modifierToUpdateIdx].compute.amount =
+          math.add(prevAmount, difference);
+      }
       subOrders.splice(
         selectedSubOrderIndex,
         1,

package/lib/order/splitByDepartments.js

@@ -80,6 +80,9 @@ module.exports = ({ utils, _, itemActions, modifierActions, settings }) => {
     return (deps.length && deps[0].name) || 'other';
   };
 
+  const isSplitByPieces = splitUnit => splitUnit === 'pieces';
+  const isSplitByWeight = splitUnit => splitUnit === 'weight';
+
   return function splitByDepartments(order) {
     const { items } = order;
     const itemsByDepartments = _.groupBy(items, getDepartmentName);
@@ -94,11 +97,37 @@ module.exports = ({ utils, _, itemActions, modifierActions, settings }) => {
       const departmentName = getDepartmentName(newItems[0]);
       const maxItems = modifierActions.getDepartmentMaxItems(department);
 
-      if (
-        department &&
-        maxItems &&
-        itemActions.getItemsTotalPieces(newItems) > maxItems
-      ) {
+      const autoSplit = _.get(
+        department || {},
+        'properties.department.autoSplit',
+        false
+      );
+
+      const splitUnit = _.get(
+        department || {},
+        'properties.department.splitUnit',
+        'quantity'
+      );
+
+      const getItemsTotalCount = itemsParam => {
+        if (isSplitByPieces(splitUnit))
+          return itemActions.getItemsTotalPieces(itemsParam);
+        if (isSplitByWeight(splitUnit))
+          return itemActions.getItemsTotalWeight(itemsParam);
+        return itemActions.getItemsTotalQuantity(itemsParam);
+      };
+
+      const getItemTotalCount = itemParam => {
+        if (isSplitByPieces(splitUnit))
+          return itemActions.getTotalPieces(itemParam);
+        if (isSplitByWeight(splitUnit))
+          return itemActions.getTotalWeight(itemParam);
+        return itemActions.getTotalQuantity(itemParam);
+      };
+
+      const totalCount = getItemsTotalCount(newItems);
+
+      if (department && autoSplit && maxItems && totalCount > maxItems) {
         newItems.forEach(newItem => {
           for (let j = 0; j < newItem.quantity; j += 1) {
             const item = {
@@ -106,11 +135,12 @@ module.exports = ({ utils, _, itemActions, modifierActions, settings }) => {
               quantity: 1,
               _id: helpers.getObjectID(),
             };
-            const totalPieces = itemActions.getTotalPieces(item);
+            const totalCountPerItem = getItemTotalCount(item);
+
             const index = splitOrders.findIndex(
               newOrder =>
                 newOrder.items &&
-                itemActions.getItemsTotalPieces(newOrder.items) + totalPieces <=
+                getItemsTotalCount(newOrder.items) + totalCountPerItem <=
                   maxItems &&
                 departmentName === getDepartmentName(newOrder.items[0])
             );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -36,5 +36,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "a864feac96c47884de2da753f60ea69856bcb914"
+  "gitHead": "fed12242f23f92ff8cad9122afd770e6569f627a"
 }

package/lib/modifier/includePiecesInQuantity.js

@@ -1,10 +0,0 @@
-module.exports = () =>
-  function includePiecesInQuantity(modifier) {
-    return (
-      (modifier &&
-        modifier.properties &&
-        modifier.properties.department &&
-        modifier.properties.department.includePieces) ||
-      false
-    );
-  };