@darkpos/pricing 1.0.138 → 1.0.140

package/__TEST__/item.test.js

@@ -2570,5 +2570,112 @@ describe('Item actions', () => {
         'City Tax': 3,
       });
     });
+
+    test('mergeWithParentItem adds price, name, and modifiers to parent', () => {
+      const parentItem = {
+        _id: 'parent-1',
+        itemId: 'parent-1',
+        name: 'Parent',
+        price: 100,
+        total: 100,
+        quantity: 1,
+        modifiers: [
+          {
+            _id: 'mod-parent',
+            modifierId: 'mod-parent',
+          },
+        ],
+      };
+
+      const order = {
+        items: [parentItem],
+        modifiers: [],
+      };
+
+      const relatedItem = {
+        itemId: 'child-1',
+        name: 'Child',
+        price: 25,
+        modifiers: [
+          {
+            _id: 'tax',
+            compute: { amount: 5, type: 'fixed', action: 'add' },
+          },
+        ],
+        properties: {
+          relatedItem: true,
+          parentId: parentItem._id,
+          parentItemId: parentItem.itemId,
+          mergeWithParentItem: true,
+        },
+      };
+
+      const { updatedOrder } = pricingService.order.addItem({
+        order,
+        item: relatedItem,
+      });
+
+      expect(updatedOrder.items.length).toBe(1);
+
+      expect(updatedOrder.items[0]._id).toBe('parent-1');
+
+      expect(updatedOrder.items[0].price).toBe(125);
+      expect(updatedOrder.items[0].name).toBe('Parent - Child');
+      expect(updatedOrder.items[0].modifiers.length).toBe(2);
+      expect(updatedOrder.items[0].modifiers[0]._id).toBe('mod-parent');
+      expect(updatedOrder.items[0].modifiers[1].modifierId).toBe('tax');
+    });
+
+    test('mergeWithParentItem does not duplicate parent modifiers', () => {
+      const parentItem = {
+        _id: 'parent-2',
+        itemId: 'parent-2',
+        name: 'Parent',
+        price: 100,
+        total: 100,
+        quantity: 1,
+        modifiers: [
+          {
+            _id: 'mod-shared-parent',
+            modifierId: 'mod-shared',
+          },
+        ],
+      };
+
+      const order = {
+        items: [parentItem],
+        modifiers: [],
+      };
+
+      const relatedItem = {
+        itemId: 'child-2',
+        name: 'Child',
+        price: 10,
+        modifiers: [
+          {
+            _id: 'mod-shared',
+            compute: { amount: 2, type: 'fixed', action: 'add' },
+          },
+        ],
+        properties: {
+          relatedItem: true,
+          parentId: parentItem._id,
+          parentItemId: parentItem.itemId,
+          mergeWithParentItem: true,
+        },
+      };
+
+      const { updatedOrder } = pricingService.order.addItem({
+        order,
+        item: relatedItem,
+      });
+
+      expect(updatedOrder.items.length).toBe(1);
+      expect(updatedOrder.items[0]._id).toBe('parent-2');
+      expect(updatedOrder.items[0].price).toBe(110);
+      expect(updatedOrder.items[0].name).toBe('Parent - Child');
+      expect(updatedOrder.items[0].modifiers.length).toBe(1);
+      expect(updatedOrder.items[0].modifiers[0].modifierId).toBe('mod-shared');
+    });
   });
 });

package/__TEST__/order/addItem.test.js

@@ -18,6 +18,7 @@ describe('addItem function', () => {
 
     // Mock item to add
     const item = {
+      _id: 'abc',
       itemId: '123',
       quantity: 1,
       price: 100,

package/__TEST__/order/order.test.js

@@ -3808,6 +3808,27 @@ describe('Order actions', () => {
     expect(newOrder2.items[0].status).toMatchObject({ paid: { value: true } });
   });
 
+  test('Mark paid status true if totalPaid is greater than total', () => {
+    const orderItem = {
+      price: 25,
+      quantity: 1,
+      status: {},
+      totalPaid: 30,
+    };
+    const pricing = usePricing({
+      store: { _settings: { order: { autoMarkAsPaid: false } } },
+    });
+    const order = { items: [orderItem], status: {} };
+    const newOrder = pricing.order.calculate(order);
+
+    expect(newOrder).toHaveProperty('total', 25);
+    expect(newOrder).toHaveProperty('totalPaid', 30);
+    expect(newOrder.status).toMatchObject({ paid: true });
+    expect(newOrder.items[0].status).toMatchObject({
+      paid: { value: true },
+    });
+  });
+
   test('Dont update status if not needed', () => {
     const orderItem = {
       price: 25,

package/lib/item/getOverpaidAmount.js

@@ -0,0 +1,7 @@
+module.exports = ({ utils }) =>
+  function getOverpaidAmount({ item }) {
+    const total = Number(item.total || 0);
+    const totalPaid = Number(item.totalPaid || 0);
+
+    return utils.math.sub(totalPaid, total);
+  };

package/lib/item/getPaidStatus.js

@@ -9,21 +9,21 @@ module.exports = ({ actions, settings }) =>
     const total = totalParam || 0;
     const totalPaid = totalPaidParam || 0;
 
-    if (
-      actions.isPaid({ item: { status: localStatus } }) &&
-      total !== 0 &&
-      total > totalPaid
-    ) {
+    const isPaid = actions.isPaid({ item: { status: localStatus } });
+
+    const paid = { value: true, date: new Date() };
+
+    if (isPaid && total !== 0 && total > totalPaid) {
       return undefined;
     }
 
+    if (!isPaid && totalPaid > total) return paid;
+
     if (!settings || !settings.order || !settings.order.autoMarkAsPaid) {
       return localStatus.paid;
     }
 
-    if (!actions.isPaid({ item: { status: localStatus } }) && total === 0) {
-      return { value: true, date: new Date() };
-    }
+    if (!isPaid && total === 0) return paid;
 
     return localStatus.paid;
   };

package/lib/item/index.js

@@ -74,6 +74,7 @@ const isSerialLengthValid = require('./isSerialLengthValid');
 const getSerialStatus = require('./getSerialStatus');
 const removeDepartmentModifiers = require('./removeDepartmentModifiers');
 const isRemoveParentItem = require('./isRemoveParentItem');
+const isMergeWithParentItem = require('./isMergeWithParentItem');
 const hasRelatedItems = require('./hasRelatedItems');
 const getAddModifiers = require('./getAddModifiers');
 const hasAddModifiers = require('./hasAddModifiers');
@@ -81,6 +82,8 @@ const getTaxes = require('./getTaxes');
 const getAmountToPayById = require('./getAmountToPayById');
 const applyPayment = require('./applyPayment');
 const getBalanceForPaymentModifier = require('./getBalanceForPaymentModifier');
+const isOverpaid = require('./isOverpaid');
+const getOverpaidAmount = require('./getOverpaidAmount');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -168,6 +171,7 @@ const itemActions = (deps = {}) => {
     getSerialStatus: getSerialStatus(innerDeps),
     removeDepartmentModifiers: removeDepartmentModifiers(innerDeps),
     isRemoveParentItem: isRemoveParentItem(innerDeps),
+    isMergeWithParentItem: isMergeWithParentItem(innerDeps),
     hasRelatedItems: hasRelatedItems(innerDeps),
     getAddModifiers: getAddModifiers(innerDeps),
     hasAddModifiers: hasAddModifiers(innerDeps),
@@ -175,6 +179,8 @@ const itemActions = (deps = {}) => {
     getAmountToPayById: getAmountToPayById(innerDeps),
     applyPayment: applyPayment(innerDeps),
     getBalanceForPaymentModifier: getBalanceForPaymentModifier(innerDeps),
+    isOverpaid: isOverpaid(innerDeps),
+    getOverpaidAmount: getOverpaidAmount(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/isMergeWithParentItem.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isMergeWithParentItem(item) {
+    return !!(item && item.properties && item.properties.mergeWithParentItem);
+  };

package/lib/item/isOverpaid.js

@@ -0,0 +1,7 @@
+module.exports = () =>
+  function isOverpaid({ item }) {
+    const total = Number(item.total || 0);
+    const totalPaid = Number(item.totalPaid || 0);
+
+    return totalPaid > total;
+  };

package/lib/modifier/index.js

@@ -182,6 +182,7 @@ const getCountPerCustomer = require('./getCountPerCustomer');
 const getAmountMultiplier = require('./getAmountMultiplier');
 const isAmountMultiplier = require('./isAmountMultiplier');
 const isRemoveParentItem = require('./isRemoveParentItem');
+const isMergeWithParentItem = require('./isMergeWithParentItem');
 const isTax = require('./isTax');
 
 const modifierActions = (deps = {}) => {
@@ -377,6 +378,7 @@ const modifierActions = (deps = {}) => {
     getAmountMultiplier: getAmountMultiplier(innerDeps),
     isAmountMultiplier: isAmountMultiplier(innerDeps),
     isRemoveParentItem: isRemoveParentItem(innerDeps),
+    isMergeWithParentItem: isMergeWithParentItem(innerDeps),
     isTax: isTax(innerDeps),
   });
 

package/lib/modifier/isMergeWithParentItem.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function isMergeWithParentItem(modifier) {
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.group &&
+      modifier.properties.group.mergeWithParentItem
+    );
+  };

package/lib/order/addItem.js

@@ -253,7 +253,7 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       nextItemIndex,
     });
 
-    if (reArrangedOrder && newIndex) {
+    if (reArrangedOrder && newIndex >= 0) {
       nextOrder = { ...reArrangedOrder };
       nextItemIndex = newIndex;
     }
@@ -262,7 +262,7 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
 
     if (combined && pendingItemIndex > -1 && idx !== itemIndex) {
       const idxToRemove = actions.getPendingItemIndex(nextOrder);
-      nextOrder.items.splice(idxToRemove, 1);
+      if (idxToRemove > -1) nextOrder.items.splice(idxToRemove, 1);
     }
 
     nextOrder = actions.addModifiersToParentItem({
@@ -270,10 +270,29 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       relatedItem: orderItem,
     });
 
+    const relatedItemFromOrder =
+      actions.getSelectedItem({ order: nextOrder, itemIndex: nextItemIndex }) ||
+      nextItem ||
+      orderItem;
+
+    let newItem = relatedItemFromOrder;
+
+    if (itemActions.isMergeWithParentItem(relatedItemFromOrder)) {
+      const result = actions.mergeRelatedItemWithParentItem({
+        order: nextOrder,
+        relatedItem: relatedItemFromOrder,
+        originalItem: item,
+      });
+      nextOrder = result.order;
+      newItem = result.parent;
+    }
+
     return {
       updatedOrder: nextOrder,
-      itemIndex: nextItemIndex,
-      item: nextItem,
+      item: newItem,
+      itemIndex: nextOrder.items.findIndex(
+        eachItem => eachItem._id === newItem._id
+      ),
     };
   };
 };

package/lib/order/getOverpaidAmount.js

@@ -0,0 +1,8 @@
+module.exports = ({ utils }) =>
+  function getOverPaidAmount({ order }) {
+    if (!order) return 0;
+    const total = Number(order.total || 0);
+    const totalPaid = Number(order.totalPaid || 0);
+
+    return utils.math.sub(totalPaid, total);
+  };

package/lib/order/index.js

@@ -95,10 +95,12 @@ const setPieces = require('./setPieces');
 const copyItemToParents = require('./copyItemToParents');
 const getItemsWithParents = require('./getItemsWithParents');
 const addModifiersToParentItem = require('./addModifiersToParentItem');
+const mergeRelatedItemWithParentItem = require('./mergeRelatedItemWithParentItem');
 const removeEmptyNotes = require('./removeEmptyNotes');
 const getTaxes = require('./getTaxes');
 const getPickedStatus = require('./getPickedStatus');
 const calculateWithPayment = require('./calculateWithPayment');
+const getOverpaidAmount = require('./getOverpaidAmount');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -205,10 +207,12 @@ const orderActions = (deps = {}) => {
     copyItemToParents: copyItemToParents(innerDeps),
     getItemsWithParents: getItemsWithParents(innerDeps),
     addModifiersToParentItem: addModifiersToParentItem(innerDeps),
+    mergeRelatedItemWithParentItem: mergeRelatedItemWithParentItem(innerDeps),
     removeEmptyNotes: removeEmptyNotes(innerDeps),
     getTaxes: getTaxes(innerDeps),
     getPickedStatus: getPickedStatus(innerDeps),
     calculateWithPayment: calculateWithPayment(innerDeps),
+    getOverpaidAmount: getOverpaidAmount(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/mergeRelatedItemWithParentItem.js

@@ -0,0 +1,94 @@
+module.exports = ({ actions, itemActions, utils }) => {
+  const { math } = utils;
+
+  return function mergeRelatedItemWithParentItem({
+    order,
+    relatedItem,
+    originalItem,
+  }) {
+    if (
+      !order ||
+      !itemActions.isRelatedItem(relatedItem) ||
+      (!itemActions.isMergeWithParentItem(originalItem) &&
+        !itemActions.isMergeWithParentItem(relatedItem))
+    ) {
+      return order;
+    }
+
+    if (!Array.isArray(order.items)) return order;
+
+    const nextOrder = { ...order };
+
+    const parentItem = itemActions.getParentItem(nextOrder.items, relatedItem);
+    if (!parentItem) return nextOrder;
+
+    const parentIndex = actions.getItemIndex({
+      order: nextOrder,
+      item: parentItem,
+    });
+    if (parentIndex < 0) return nextOrder;
+
+    const relatedIndex = actions.getItemIndex({
+      order: nextOrder,
+      item: relatedItem,
+    });
+    if (relatedIndex < 0) return nextOrder;
+
+    let updatedParent = parentItem;
+
+    if (relatedItem && relatedItem.name) {
+      if (!updatedParent.name) updatedParent.name = relatedItem.name;
+      else if (!updatedParent.name.includes(relatedItem.name)) {
+        updatedParent.name = `${updatedParent.name} - ${relatedItem.name}`;
+      }
+    }
+
+    if (typeof relatedItem.price === 'number') {
+      updatedParent.price = math.add(
+        updatedParent.price || 0,
+        relatedItem.price
+      );
+    }
+
+    nextOrder.items = [...nextOrder.items];
+    nextOrder.items[parentIndex] = updatedParent;
+
+    const relatedModifiers = Array.isArray(relatedItem.modifiers)
+      ? relatedItem.modifiers
+      : [];
+
+    if (relatedModifiers.length) {
+      const parentModifierIds = (updatedParent.modifiers || [])
+        .map(mod => mod.modifierId || mod._id)
+        .filter(Boolean);
+
+      const modifiersToAdd = relatedModifiers.filter(mod => {
+        const modId = mod.modifierId || mod._id;
+        return modId && !parentModifierIds.includes(modId);
+      });
+
+      if (modifiersToAdd.length) {
+        const orderWithModifiers = modifiersToAdd.reduce(
+          (acc, modifier) =>
+            actions.addItemModifier({
+              itemIndex: parentIndex,
+              order: acc,
+              modifier,
+              originalItem: updatedParent,
+            }),
+          nextOrder
+        );
+        nextOrder.items = orderWithModifiers.items;
+      }
+    }
+
+    updatedParent =
+      actions.getSelectedItem({ order: nextOrder, itemIndex: parentIndex }) ||
+      updatedParent;
+
+    nextOrder.items[parentIndex] = updatedParent;
+    nextOrder.items.splice(relatedIndex, 1);
+
+    return { order: nextOrder, parent: updatedParent };
+  };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.138",
+  "version": "1.0.140",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -53,5 +53,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "95d90c9dccaf934d7d4a8adc8e46115e90b81664"
+  "gitHead": "a679a827cb2a83762ae4ec5ce76ae5416b654a48"
 }