@darkpos/pricing 1.0.125 → 1.0.128

package/__TEST__/order/order.test.js

@@ -2446,155 +2446,6 @@ describe('Order actions', () => {
     });
   });
 
-  test('CU-86dueyuqj ->  Merge Parent orders', () => {
-    const item1 = {
-      _id: 1,
-      price: 10,
-      quantity: 1,
-      modifiers: [],
-    };
-    const item2 = {
-      _id: 2,
-      price: 20,
-      quantity: 1,
-      modifiers: [],
-    };
-
-    const user = {
-      _id: 'userId123',
-      firstName: 'Esteban',
-      lastName: 'Mero',
-    };
-
-    const childOrder1 = pricingService.order.calculate({
-      items: [item1],
-      _id: 'abc',
-      _parentId: 1,
-    });
-    const childOrder2 = pricingService.order.calculate({
-      items: [item2],
-      _id: 'bcd',
-      _parentId: 2,
-    });
-
-    const parentOrder1 = {
-      items: [],
-      orders: [childOrder1],
-      _isParent: true,
-      _id: 1,
-    };
-    const parentOrder2 = {
-      items: [],
-      orders: [childOrder2],
-      _isParent: true,
-      _id: 2,
-    };
-
-    const [newParentOrder, voidedOrders, ordersToDelete, subOrders] =
-      pricingService.order.merge({
-        orders: [parentOrder1, parentOrder2],
-        subOrdersToMerge: [childOrder1, childOrder2],
-        aggregateItems: true,
-        user,
-      });
-
-    expect(newParentOrder).toHaveProperty('total', 30);
-    expect(voidedOrders.length).toBe(1);
-    expect(ordersToDelete.length).toBe(0);
-    expect(subOrders.length).toBe(2);
-    expect(newParentOrder.orders.length).toBe(2);
-  });
-
-  test('CU-86dueyuqj ->  Merge Orders that are not parents and not children', () => {
-    const item1 = {
-      _id: 1,
-      price: 10,
-      quantity: 1,
-      modifiers: [],
-    };
-    const item2 = {
-      _id: 2,
-      price: 20,
-      quantity: 1,
-      modifiers: [],
-    };
-
-    const user = {
-      _id: 'userId123',
-      firstName: 'Esteban',
-      lastName: 'Mero',
-    };
-
-    const order1 = pricingService.order.calculate({
-      items: [item1],
-      _id: 'abc',
-    });
-    const order2 = pricingService.order.calculate({
-      items: [item2],
-      _id: 'bcd',
-    });
-
-    const [newOrder, voidedOrders, ordersToDelete, subOrders] =
-      pricingService.order.merge({
-        orders: [order1, order2],
-        subOrdersToMerge: [],
-        aggregateItems: true,
-        user,
-      });
-
-    expect(newOrder).toHaveProperty('total', 30);
-    expect(voidedOrders.length).toBe(1);
-    expect(ordersToDelete.length).toBe(0);
-    expect(subOrders.length).toBe(0);
-    expect(newOrder.orders).toBe(undefined);
-  });
-
-  test('CU-86dueyuqj ->  Merge Child orders', () => {
-    const item1 = {
-      _id: 1,
-      price: 10,
-      quantity: 1,
-      modifiers: [],
-    };
-    const item2 = {
-      _id: 2,
-      price: 20,
-      quantity: 1,
-      modifiers: [],
-    };
-
-    const user = {
-      _id: 'userId123',
-      firstName: 'Esteban',
-      lastName: 'Mero',
-    };
-
-    const childOrder1 = pricingService.order.calculate({
-      items: [item1],
-      _id: 'abc',
-      _parentId: 1,
-    });
-    const childOrder2 = pricingService.order.calculate({
-      items: [item2],
-      _id: 'bcd',
-      _parentId: 1,
-    });
-
-    const [newParentOrder, voidedOrders, ordersToDelete, subOrders] =
-      pricingService.order.merge({
-        orders: [childOrder1, childOrder2],
-        subOrdersToMerge: [],
-        aggregateItems: true,
-        user,
-      });
-
-    expect(newParentOrder).toHaveProperty('total', 30);
-    expect(voidedOrders.length).toBe(1);
-    expect(ordersToDelete.length).toBe(0);
-    expect(subOrders.length).toBe(0);
-    expect(newParentOrder.orders).toBe(undefined);
-  });
-
   test('Get calculated Order, multiple items and indirect modifiers #2 toNeareastMultiple', () => {
     const pricingService2 = usePricing({
       store: { _settings: { localization: { nearestMultiple: '0.5' } } },

package/lib/modifier/isEmptyOverride.js

@@ -5,8 +5,6 @@ module.exports = ({ actions }) =>
     const computeAmount = modifier.compute && modifier.compute.amount;
     const { fixedValue } = modifier.properties.override;
 
-    console.log({ computeAmount, fixedValue });
-
     const result =
       typeof computeAmount !== 'number' && typeof fixedValue !== 'number';
 

package/lib/order/calculate.js

@@ -150,6 +150,9 @@ module.exports = ({
     const { subTotals, subTotal, total } =
       itemActions.getItemsTotals(calculatedItems);
 
+    const pieceCount = calculatedItems.length
+      ? itemActions.getItemsTotalPieces(calculatedItems)
+      : order.properties.pieceCount;
     return {
       ...order,
       subTotals,
@@ -157,5 +160,9 @@ module.exports = ({
       total,
       items: calculatedItems,
       status: actions.getUpdatedStatus({ status: order.status, total }),
+      properties: {
+        ...(order.properties || {}),
+        pieceCount,
+      },
     };
   };

package/lib/order/index.js

@@ -50,7 +50,6 @@ const getTotals = require('./getTotals');
 const getDepartmentModifiers = require('./getDepartmentModifiers');
 const getCustomerStoreCredit = require('./getCustomerStoreCredit');
 const getTip = require('./getTip');
-const merge = require('./merge');
 const calculateOrdersDue = require('./calculateOrdersDue');
 const removeModifierByAttribute = require('./removeModifierByAttribute');
 const removeApplyModifier = require('./removeApplyModifier');
@@ -155,7 +154,6 @@ const orderActions = (deps = {}) => {
     getDepartmentModifiers: getDepartmentModifiers(innerDeps),
     getCustomerStoreCredit: getCustomerStoreCredit(innerDeps),
     getTip: getTip(innerDeps),
-    merge: merge(innerDeps),
     calculateOrdersDue: calculateOrdersDue(innerDeps),
     removeModifierByAttribute: removeModifierByAttribute(innerDeps),
     removeApplyModifier: removeApplyModifier(innerDeps),

package/lib/order/setPieces.js

@@ -13,10 +13,12 @@ module.exports = ({ utils }) => {
     );
 
     if (Array.isArray(nextOrder.properties.pieces)) {
-      nextOrder.properties.pieces = nextOrder.properties.pieces.map(pc => ({
-        ...pc,
-        count: helpers.toNumberOrZero(pc.count),
-      }));
+      nextOrder.properties.pieces = nextOrder.properties.pieces
+        .map(pc => ({
+          ...pc,
+          count: helpers.toNumberOrZero(pc.count),
+        }))
+        .filter(pc => pc.count > 0);
     }
 
     return nextOrder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.125",
+  "version": "1.0.128",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -46,14 +46,11 @@
     "eslint": "^8.2.0",
     "eslint-config-airbnb": "^19.0.4",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-jest": "^26.5.3",
-    "eslint-plugin-prettier": "^4.0.0",
     "jest": "^28.1.1",
-    "prettier": "^2.7.0",
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "75e2c7fc1237e4cb3fd5f019390d314ada58229f"
+  "gitHead": "8246fe8ba99264f6428a8fa725fb951b49961c95"
 }

package/lib/order/merge.js

@@ -1,96 +0,0 @@
-module.exports = ({ _, actions, utils }) => {
-  const { math } = utils;
-
-  const isAggregatableItems = (first, second) => {
-    if (
-      first.itemId !== second.itemId ||
-      first.price !== second.price ||
-      first.description !== second.description ||
-      (first.modifiers && !second.modifiers) ||
-      (!first.modifiers && second.modifiers) ||
-      first.modifiers.length !== second.modifiers.length
-    ) {
-      return false;
-    }
-    let hasInvalidModifier = false;
-    first.modifiers.forEach(modifier => {
-      if (!second.modifiers.find(mod => mod._id === modifier._id)) {
-        hasInvalidModifier = true;
-      }
-    });
-
-    return !hasInvalidModifier;
-  };
-
-  // return: [Order, Order, Array<Order>]
-  return function merge({ orders, subOrdersToMerge, aggregateItems, user }) {
-    const items = orders.reduce((res, order) => res.concat(order.items), []);
-    let newOrder = null;
-    // Unique Orders
-    const mOrders = _.uniqBy(orders, '_id');
-    if (aggregateItems) {
-      const newItems = [];
-      items.forEach(item => {
-        const repeatedItem = newItems.find(each =>
-          isAggregatableItems(each, item)
-        );
-        if (repeatedItem) {
-          repeatedItem.quantity = math.add(
-            repeatedItem.quantity,
-            item.quantity
-          );
-        } else {
-          newItems.push({ ...item });
-        }
-      });
-      newOrder = {
-        ...mOrders[0],
-        items: newItems,
-      };
-    } else {
-      newOrder = {
-        ...mOrders[0],
-        items,
-      };
-    }
-
-    const ordersToDelete = [];
-    const voidedOrders = [];
-    for (let i = 1; i < mOrders.length; i += 1) {
-      if (mOrders[i] && mOrders[i].parentId) {
-        ordersToDelete.push(mOrders[i]);
-      } else {
-        let voidedOrder = actions.voidOrder(mOrders[i]);
-        if (!voidedOrder) return null;
-        voidedOrder.isParent = false;
-        voidedOrder = actions.addNote({
-          order: voidedOrder,
-          message: `This order was merged into order #${mOrders[i].displayId}`,
-          user,
-        });
-        voidedOrders.push(voidedOrder);
-      }
-    }
-
-    let subOrders = [];
-    if (newOrder && subOrdersToMerge && subOrdersToMerge.length > 0) {
-      subOrders = subOrdersToMerge.map(s => ({
-        ...s,
-        parentId: newOrder._id,
-        customer: newOrder.customer,
-      }));
-      newOrder.orders = subOrders;
-    }
-
-    newOrder = actions.calculate(newOrder);
-    newOrder = actions.addNote({
-      order: newOrder,
-      message: `This order was merged with ${
-        mOrders.length === 2 ? ` order ` : ` orders `
-      } # ${mOrders.slice(1).map(order => ` ${order.displayId}`)}`,
-      user,
-    });
-
-    return [newOrder, voidedOrders, ordersToDelete, subOrders];
-  };
-};