@darkpos/pricing 1.0.34 → 1.0.37

package/__TEST__/order/order.test.js

@@ -2287,4 +2287,343 @@ describe('Order actions', () => {
       _actual: 10,
     });
   });
+
+  test('CU-86duna31h -> Get calculated Order, multiple items and indirect required discount modifiers', () => {
+    const discountModifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: `10% Discount`,
+      type: 'discount',
+      required: true,
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 10,
+      quantity: 1,
+      modifiers: [
+        {
+          ...discountModifier,
+          _parentId: discountModifier._id,
+          modifierId: discountModifier._id,
+        },
+      ],
+    };
+    const item2 = {
+      _id: 2,
+      price: 20,
+      quantity: 1,
+      modifiers: [
+        {
+          ...discountModifier,
+          _parentId: discountModifier._id,
+          modifierId: discountModifier._id,
+        },
+      ],
+    };
+
+    const order = { items: [item1, item2], modifiers: [discountModifier] };
+
+    const newOrder = pricingService.order.calculate(order);
+    expect(newOrder).toHaveProperty('total', 27);
+    expect(newOrder).toHaveProperty('subTotal', 30);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -3,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 9);
+    expect(newOrder.items[0]).toHaveProperty('subTotals', {
+      discount: -1,
+      _included: 0,
+      _xincluded: -1,
+      _direct: 0,
+      _xdirect: -1,
+      _simple: 10,
+      _actual: 10,
+    });
+    expect(newOrder.items[1]).toHaveProperty('total', 18);
+    expect(newOrder.items[1]).toHaveProperty('subTotals', {
+      discount: -2,
+      _included: 0,
+      _xincluded: -2,
+      _direct: 0,
+      _xdirect: -2,
+      _simple: 20,
+      _actual: 20,
+    });
+  });
+
+  test('CU-86duna31h -> Get calculated Order, multiple items and indirect  discount modifiers', () => {
+    const discountModifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: `10% Discount`,
+      type: 'discount',
+      required: true,
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 10,
+      quantity: 1,
+      modifiers: [],
+    };
+    const item2 = {
+      _id: 2,
+      price: 20,
+      quantity: 1,
+      modifiers: [],
+    };
+
+    const order = { items: [item1, item2], modifiers: [discountModifier] };
+
+    const newOrder = pricingService.order.calculate(order);
+    expect(newOrder).toHaveProperty('total', 27);
+    expect(newOrder).toHaveProperty('subTotal', 30);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -3,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 9);
+    expect(newOrder.items[0]).toHaveProperty('subTotals', {
+      discount: -1,
+      _included: 0,
+      _xincluded: -1,
+      _direct: 0,
+      _xdirect: -1,
+      _simple: 10,
+      _actual: 10,
+    });
+    expect(newOrder.items[1]).toHaveProperty('total', 18);
+    expect(newOrder.items[1]).toHaveProperty('subTotals', {
+      discount: -2,
+      _included: 0,
+      _xincluded: -2,
+      _direct: 0,
+      _xdirect: -2,
+      _simple: 20,
+      _actual: 20,
+    });
+  });
+
+  test('CU-86duna31h ->  Get calculated Order, multiple items and indirect required discount modifiers', () => {
+    const discountModifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: `10% Discount`,
+      type: 'discount',
+    };
+
+    const item1 = {
+      _id: 1,
+      price: 10,
+      quantity: 1,
+      modifiers: [
+        {
+          ...discountModifier,
+          _parentId: discountModifier._id,
+          modifierId: discountModifier._id,
+        },
+      ],
+    };
+    const item2 = {
+      _id: 2,
+      price: 20,
+      quantity: 1,
+      modifiers: [
+        {
+          ...discountModifier,
+          _parentId: discountModifier._id,
+          modifierId: discountModifier._id,
+        },
+      ],
+    };
+    const order = { items: [item1, item2], modifiers: [discountModifier] };
+
+    const newOrder = pricingService.order.calculate(order);
+    expect(newOrder).toHaveProperty('total', 27);
+    expect(newOrder).toHaveProperty('subTotal', 30);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: -3,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 9);
+    expect(newOrder.items[0]).toHaveProperty('subTotals', {
+      discount: -1,
+      _included: 0,
+      _xincluded: -1,
+      _direct: 0,
+      _xdirect: -1,
+      _simple: 10,
+      _actual: 10,
+    });
+    expect(newOrder.items[1]).toHaveProperty('total', 18);
+    expect(newOrder.items[1]).toHaveProperty('subTotals', {
+      discount: -2,
+      _included: 0,
+      _xincluded: -2,
+      _direct: 0,
+      _xdirect: -2,
+      _simple: 20,
+      _actual: 20,
+    });
+  });
+
+  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);
+  });
 });

package/lib/item/removeModifier.js

@@ -5,12 +5,14 @@ module.exports = ({ modifierActions, _, actions }) => {
   const isValid = (itemModifiers, modifier) => {
     if (!modifierActions.findById(itemModifiers, modifier._id)) return false;
 
-    if (
-      modifierActions.isRequired(modifier) &&
-      !modifierActions.isGroupOfValues(modifier) &&
-      !modifierActions.isRequiredAndOverride(modifier)
-    )
-      return false;
+    // 18-SEP-24 - Commenting out due to bug: https://app.clickup.com/t/86duna31h.
+    // This logic was preventing required Order Discounts to be removed from the items.
+    // if (
+    //   modifierActions.isRequired(modifier) &&
+    //   !modifierActions.isGroupOfValues(modifier) &&
+    //   !modifierActions.isRequiredAndOverride(modifier)
+    // )
+    //   return false;
 
     if (
       !modifierActions.isGroupOfItems(modifier) &&

package/lib/order/calculate.js

@@ -2,14 +2,18 @@
 /**
  * return calculated Order
  */
-module.exports = ({ _, itemActions, modifierActions }) =>
+module.exports = ({ _, actions, itemActions, modifierActions }) =>
   function calculateorder(inputOrder) {
     if (!inputOrder) return inputOrder;
     const order = _.cloneDeep(inputOrder);
-    const { items = [] } = order;
+    const { items = [], orders = [] } = order;
 
-    if (!items.length)
-      return { ...order, subTotals: {}, subTotal: 0, total: 0 };
+    if (!items.length) {
+      if (!orders.length)
+        return { ...order, subTotals: {}, subTotal: 0, total: 0 };
+
+      return { ...order, ...actions.getTotals(order.orders) };
+    }
 
     const sortedOrderModifiers = modifierActions.sort(
       modifierActions.removeLocked(order.modifiers)

package/lib/order/merge.js

@@ -54,15 +54,6 @@ module.exports = ({ _, actions, utils }) => {
       };
     }
 
-    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,
-    });
-
     const ordersToDelete = [];
     const voidedOrders = [];
     for (let i = 1; i < mOrders.length; i += 1) {
@@ -89,8 +80,18 @@ module.exports = ({ _, actions, utils }) => {
         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];
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.34",
+  "version": "1.0.37",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -36,5 +36,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "e34041588c206612b5c2dff2e27aa34ac838137e"
+  "gitHead": "880122bbb47242484095cd2db3f68036c95c569a"
 }