@darkpos/pricing 1.0.52 → 1.0.53

package/__TEST__/order/order.test.js

@@ -2620,4 +2620,45 @@ describe('Order actions', () => {
       _actual: 4.65,
     });
   });
+
+  test('CU-86dvd3dbp Get calculated Order, multiple items and indirect modifiers #2 toNeareastMultiple (No Order Modifiers)', () => {
+    const pricingService2 = usePricing({
+      store: { _settings: { localization: { nearestMultiple: '0.5' } } },
+    });
+
+    const item1 = {
+      _id: 1,
+      price: 15.99,
+      quantity: 1,
+    };
+    const item2 = {
+      _id: 2,
+      price: 4.65,
+      quantity: 1,
+    };
+
+    const order = { items: [item1, item2] };
+    const newOrder = pricingService2.order.calculate(order);
+    expect(newOrder).toHaveProperty('total', 21);
+    expect(newOrder).toHaveProperty('subTotal', 20.64);
+    expect(newOrder).toHaveProperty('subTotals', {});
+    expect(newOrder.items[0]).toHaveProperty('total', 16.35);
+    expect(newOrder.items[0]).toHaveProperty('subTotals', {
+      _included: 0,
+      _xincluded: 0,
+      _direct: 0,
+      _xdirect: 0,
+      _simple: 15.99,
+      _actual: 15.99,
+    });
+    expect(newOrder.items[1]).toHaveProperty('total', 4.65);
+    expect(newOrder.items[1]).toHaveProperty('subTotals', {
+      _included: 0,
+      _xincluded: 0,
+      _direct: 0,
+      _xdirect: 0,
+      _simple: 4.65,
+      _actual: 4.65,
+    });
+  });
 });

package/lib/order/calculate.js

@@ -40,89 +40,92 @@ module.exports = ({
       ),
     });
 
+    let calculatedItems = itemsWNIM || [];
+
     const newOrder = {
       ...order,
       ...itemActions.getItemsTotals(itemsWNIM),
       items: itemsWNIM,
     };
 
-    if (!sortedOrderModifiers.length) return newOrder;
-
-    itemsWNIM = itemActions.calculate(itemsWNIM, {});
-
-    let tempItems = itemsWNIM || items;
-    let itemsWIM = _.cloneDeep(tempItems);
-    let prvSort = null;
-
-    let computedTotal = newOrder.total;
-
-    for (const modifier of sortedOrderModifiers) {
-      const isCredit = modifierActions.isCredit(modifier);
-      const sort = modifierActions.getProperty(modifier, 'sort');
+    if (sortedOrderModifiers.length > 0) {
+      itemsWNIM = itemActions.calculate(itemsWNIM, {});
+
+      let tempItems = itemsWNIM || items;
+      let itemsWIM = _.cloneDeep(tempItems);
+      let prvSort = null;
+
+      let computedTotal = newOrder.total;
+
+      for (const modifier of sortedOrderModifiers) {
+        const isCredit = modifierActions.isCredit(modifier);
+        const sort = modifierActions.getProperty(modifier, 'sort');
+
+        if (prvSort !== sort) {
+          if (sort) {
+            tempItems = itemsWIM.map(item => ({
+              ...item,
+              modifiers: modifierActions.getModifiersByMaxSort(
+                item.modifiers,
+                modifier.properties.sort
+              ),
+            }));
+          } else {
+            tempItems = itemsWIM;
+          }
+          tempItems = itemActions.calculate(tempItems, options);
+        }
 
-      if (prvSort !== sort) {
-        if (sort) {
-          tempItems = itemsWIM.map(item => ({
-            ...item,
-            modifiers: modifierActions.getModifiersByMaxSort(
-              item.modifiers,
-              modifier.properties.sort
-            ),
-          }));
-        } else {
-          tempItems = itemsWIM;
+        if (isCredit) {
+          const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
+          computedTotal = itemActions.getItemsTotals(calculatedItemWIM).total;
         }
-        tempItems = itemActions.calculate(tempItems, options);
-      }
 
-      if (isCredit) {
-        const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
-        computedTotal = itemActions.getItemsTotals(calculatedItemWIM).total;
-      }
+        if (modifierActions.hasItems({ modifier })) {
+          tempItems = itemActions.getItems(tempItems, modifier.items);
+        }
 
-      if (modifierActions.hasItems({ modifier })) {
-        tempItems = itemActions.getItems(tempItems, modifier.items);
+        computedTotal = itemActions.getItemsTotals(tempItems).total;
+
+        const itemsModifiers = itemActions.addIndirectModifier({
+          orderTotal: computedTotal,
+          items: tempItems,
+          modifier,
+        });
+
+        // adding the modifiers to items
+        itemsWIM = itemsWIM.map(item => ({
+          ...item,
+          modifiers: [
+            ...(item.modifiers || []),
+            itemsModifiers[item._id],
+          ].filter(Boolean),
+        }));
+        prvSort = sort;
       }
 
-      computedTotal = itemActions.getItemsTotals(tempItems).total;
-
-      const itemsModifiers = itemActions.addIndirectModifier({
-        orderTotal: computedTotal,
-        items: tempItems,
-        modifier,
-      });
-
-      // adding the modifiers to items
-      itemsWIM = itemsWIM.map(item => ({
-        ...item,
-        modifiers: [...(item.modifiers || []), itemsModifiers[item._id]].filter(
-          Boolean
-        ),
-      }));
-      prvSort = sort;
+      calculatedItems = itemActions.calculate(itemsWIM, options);
     }
 
-    const calculatedItemWIM = itemActions.calculate(itemsWIM, options);
-
     const addToItemTotal = difference => {
-      if (difference > 0 && calculatedItemWIM.length) {
-        calculatedItemWIM[0].total = utils.math.toDecimalPlaces(
-          utils.math.add(calculatedItemWIM[0].total, difference)
+      if (difference > 0 && calculatedItems.length) {
+        calculatedItems[0].total = utils.math.toDecimalPlaces(
+          utils.math.add(calculatedItems[0].total, difference)
         );
       }
     };
 
-    if (calculatedItemWIM.length > 1) {
+    if (calculatedItems.length > 1) {
       const difference = itemActions.getTotalsDifference({
-        items: calculatedItemWIM,
+        items: calculatedItems,
       });
 
       addToItemTotal(difference);
     }
 
-    if (storeActions.isNeareastMultiple() && calculatedItemWIM.length > 0) {
+    if (storeActions.isNeareastMultiple() && calculatedItems.length > 0) {
       const difference = itemActions.getTotalNeareastDifference({
-        items: calculatedItemWIM,
+        items: calculatedItems,
       });
 
       if (difference > 0) addToItemTotal(difference);
@@ -130,7 +133,7 @@ module.exports = ({
 
     return {
       ...order,
-      ...itemActions.getItemsTotals(calculatedItemWIM),
-      items: calculatedItemWIM,
+      ...itemActions.getItemsTotals(calculatedItems),
+      items: calculatedItems,
     };
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.52",
+  "version": "1.0.53",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -42,5 +42,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "43e5d458336e6d49ffbcf8af2a715428364a4df5"
+  "gitHead": "ad5528b8430430e2a34e124218dc4ac1d3da1681"
 }