@darkpos/pricing 1.0.84 → 1.0.86

package/__TEST__/modifier.test.js

@@ -1855,4 +1855,74 @@ describe('Modifier actions', () => {
 
     expect(updatedOrder2.items[0].modifiers.length).toEqual(1);
   });
+
+  test('Should not add modifiers if tags do not match', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      tags: ['tagA', 'tagB'],
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+      tags: ['otherTag'],
+    });
+
+    const updatedOrder = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+    });
+
+    expect(updatedOrder.items[0].modifiers.length).toEqual(0);
+  });
+
+  test('Should add modifier if tags match', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      tags: ['tagA', 'tagB'],
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+      tags: ['tagA'],
+    });
+
+    let error = '';
+    const updatedOrder = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+      onError: err => {
+        error = err;
+      },
+    });
+
+    expect(error).toEqual('');
+
+    expect(updatedOrder.items[0].modifiers.length).toEqual(1);
+  });
 });

package/__TEST__/order/{createSuborder.test.js → addItemsToSubOrder.js}

@@ -13,24 +13,23 @@ const pricingService = usePricing(session);
 
 describe('Create suborder', () => {
   test('Create a suborder with one order', () => {
-    const subOrders = pricingService.order.createSuborder(orderMock);
     const order = {
       ...orderMock,
-      orders: subOrders,
+      orders: []
     };
-    expect(order.orders).toHaveLength(1);
+    const subOrders = pricingService.order.addItemsToSubOrder({ parentOrder: order });
+
     expect(subOrders).toHaveLength(1);
   });
 
   test('Create suborder with multiple items in the order', () => {
-    const multipleItemsOrderMock = {
+    const order = {
       ...orderMock,
+      orders: [],
       items: [item1Mock, item2Mock, item3Mock], // assuming items is an array of items
     };
-    const subOrders = pricingService.order.createSuborder(
-      multipleItemsOrderMock
-    );
+    const subOrders = pricingService.order.createSubOrder({ parentOrder: order });
 
-    expect(subOrders[0].items).toHaveLength(3); // Suborders should match number of items
+    expect(subOrders).toHaveLength(1); // Suborders should match number of items
   });
 });

package/__TEST__/order/createSubOrder.test.js

@@ -0,0 +1,33 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+const orderMock = require('../modifier/mocks/orderMock.json');
+const item1Mock = require('../mocks/items/item1Mock.json');
+const item2Mock = require('../mocks/items/item2Mock.json');
+const item3Mock = require('../mocks/items/item3Mock.json');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+describe('Create suborder', () => {
+  test('Create a suborder with one order', () => {
+    const order = {
+      ...orderMock,
+    };
+    const subOrder = pricingService.order.createSubOrder({ parentOrder: order, items: order.items });
+
+    expect(subOrder.items).toHaveLength(1);
+  });
+
+  test('Create suborder with multiple items in the order', () => {
+    const order = {
+      ...orderMock,
+      items: [item1Mock, item2Mock, item3Mock], // assuming items is an array of items
+    };
+    const subOrder = pricingService.order.createSubOrder({ parentOrder: order, items: order.items });
+
+    expect(subOrder.items).toHaveLength(3); // Suborders should match number of items
+  });
+});

package/lib/item/index.js

@@ -59,6 +59,7 @@ const adjustFixedModifiersDifference = require('./adjustFixedModifiersDifference
 const validateCreditModifiersTotal = require('./validateCreditModifiersTotal');
 const adjustCreditModifiersDifference = require('./adjustCreditModifiersDifference');
 const getSubtotal = require('./getSubtotal');
+const isSomeTagsMatch = require('./isSomeTagsMatch');
 const getTotals = require('./getTotals');
 const patchItem = require('./patchItem');
 
@@ -133,6 +134,7 @@ const itemActions = (deps = {}) => {
     validateCreditModifiersTotal: validateCreditModifiersTotal(innerDeps),
     adjustCreditModifiersDifference: adjustCreditModifiersDifference(innerDeps),
     getSubtotal: getSubtotal(innerDeps),
+    isSomeTagsMatch: isSomeTagsMatch(innerDeps),
     getTotals: getTotals(innerDeps),
     patchItem: patchItem(innerDeps),
   });

package/lib/item/isSomeTagsMatch.js

@@ -0,0 +1,13 @@
+module.exports = () =>
+  function isSomeTagsMatch({ item, tags }) {
+    if (
+      !item ||
+      !Array.isArray(item.tags) ||
+      item.tags.length === 0 ||
+      !Array.isArray(tags) ||
+      tags.length === 0
+    )
+      return true;
+
+    return item.tags.some(tag => tags.includes(tag));
+  };

package/lib/order/addItemModifier.js

@@ -180,6 +180,11 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     if (!order || itemIndex < 0 || !modifier) return order;
 
     let item = actions.getSelectedItem({ order, itemIndex });
+
+    if (!itemActions.isSomeTagsMatch({ item, tags: modifier.tags })) {
+      return order;
+    }
+
     const customer = actions.getCustomer(order);
     const contains =
       !_.isEmpty(item.modifiers) &&

package/lib/order/addItemsToSubOrder.js

@@ -0,0 +1,15 @@
+module.exports = ({ actions }) =>
+  function addItemsToSubOrder({ parentOrder, index }) {
+    let subOrders = parentOrder.orders || [];
+    const newSubOrders = [];
+    const items = actions.getNewItems({ parentOrder });
+
+    if (items.length > 0) {
+      if (subOrders.length === 0 || index === -1)
+        newSubOrders.push(actions.createSubOrder({ parentOrder, items }));
+      else subOrders[index || subOrders.length - 1].items.push(...items);
+    }
+
+    subOrders = actions.mapSubOrders({ parentOrder, newSubOrders });
+    return subOrders;
+  };

package/lib/order/autoSplit.js

@@ -1,34 +1,12 @@
 module.exports = ({ actions }) =>
   function autoSplit({ parentOrder }) {
-    let subOrders = parentOrder.orders || [];
     let newSubOrders = [];
-    const existingItems = subOrders
-      .map(subOrder => subOrder.items || [])
-      .flat();
-    const newItems = parentOrder.items.filter(item => {
-      const existingItem = existingItems.find(
-        eItem => String(eItem._id) === String(item._id)
-      );
-      return !existingItem;
-    });
 
+    const newItems = actions.getNewItems({ parentOrder });
     if (newItems.length > 0) {
-      newSubOrders = actions.splitByDepartments({
-        ...parentOrder,
-        items: newItems,
-      });
+      newSubOrders = actions.splitByDepartments({ parentOrder, newItems });
     }
 
-    // reassign displayIds
-    subOrders = [...subOrders, ...newSubOrders].map((subOrder, idx) => ({
-      ...subOrder,
-      displayId: `${parentOrder.displayId}-${idx + 1}`,
-    }));
-
-    subOrders = actions.spreadModifiers({
-      parentOrder,
-      subOrders,
-    });
-
+    const subOrders = actions.mapSubOrders({ parentOrder, newSubOrders });
     return subOrders;
   };

package/lib/order/createSubOrder.js

@@ -0,0 +1,24 @@
+module.exports = ({ actions }) =>
+  function createSubOrder({ parentOrder, items }) {
+    const subOrder = actions.create({
+      // ...order,
+      displayId: null,
+      discount: 0,
+      tax: 0,
+      totalPaid: 0,
+      total: 0,
+      status: {
+        order: 'open',
+        delivery: parentOrder.status.delivery,
+        detailed: parentOrder.status.detailed,
+        fullyPaid: false,
+        fullyPicked: false,
+      },
+      parentId: parentOrder._id,
+      items,
+      modifiers: [],
+      notes: parentOrder.notes || [],
+    });
+
+    return subOrder;
+  };

package/lib/order/getNewItems.js

@@ -0,0 +1,15 @@
+module.exports = () =>
+  function getNewItems({ parentOrder }) {
+    const subOrders = parentOrder.orders || [];
+    const existingItems = subOrders
+      .map(subOrder => subOrder.items || [])
+      .flat();
+    const newItems = parentOrder.items.filter(item => {
+      const existingItem = existingItems.find(
+        eItem => String(eItem._id) === String(item._id)
+      );
+      return !existingItem;
+    });
+
+    return newItems;
+  };

package/lib/order/index.js

@@ -42,7 +42,8 @@ const unpickOrder = require('./unpick');
 const isDetailed = require('./isDetailed');
 const splitByDepartments = require('./splitByDepartments');
 const autoSplit = require('./autoSplit');
-const syncSubOrderItemsFromParent = require('./syncSubOrderItemsFromParent');
+const addItemsToSubOrder = require('./addItemsToSubOrder');
+const mergeItemsWithSubOrders = require('./mergeItemsWithSubOrders');
 const createParent = require('./createParent');
 const getOrdersPieces = require('./getOrdersPieces');
 const getTotals = require('./getTotals');
@@ -79,8 +80,7 @@ const validateCreditModifiersTotal = require('./validateCreditModifiersTotal');
 const validateFixedModifiersTotal = require('./validateFixedModifiersTotal');
 const removeModifiers = require('./removeModifiers');
 const addModifiers = require('./addModifiers');
-const createSuborder = require('./createSuborder');
-const getSuborder = require('./getSuborder');
+const createSubOrder = require('./createSubOrder');
 const manualSplit = require('./manualSplit');
 const manualSplitByQuantity = require('./manualSplitByQuantity');
 const applyPayment = require('./applyPayment');
@@ -89,6 +89,8 @@ const getLastLocation = require('./getLastLocation');
 const getModifierRelations = require('./getModifierRelations');
 const resetItem = require('./resetItem');
 const splitItems = require('./splitItems');
+const getNewItems = require('./getNewItems');
+const mapSubOrders = require('./mapSubOrders');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -142,7 +144,8 @@ const orderActions = (deps = {}) => {
     isDetailed: isDetailed(innerDeps),
     splitByDepartments: splitByDepartments(innerDeps),
     autoSplit: autoSplit(innerDeps),
-    syncSubOrderItemsFromParent: syncSubOrderItemsFromParent(innerDeps),
+    addItemsToSubOrder: addItemsToSubOrder(innerDeps),
+    mergeItemsWithSubOrders: mergeItemsWithSubOrders(innerDeps),
     createParent: createParent(innerDeps),
     getOrdersPieces: getOrdersPieces(innerDeps),
     getTotals: getTotals(innerDeps),
@@ -179,8 +182,7 @@ const orderActions = (deps = {}) => {
     validateFixedModifiersTotal: validateFixedModifiersTotal(innerDeps),
     removeModifiers: removeModifiers(innerDeps),
     addModifiers: addModifiers(innerDeps),
-    createSuborder: createSuborder(innerDeps),
-    getSuborder: getSuborder(innerDeps),
+    createSubOrder: createSubOrder(innerDeps),
     manualSplit: manualSplit(innerDeps),
     manualSplitByQuantity: manualSplitByQuantity(innerDeps),
     applyPayment: applyPayment(innerDeps),
@@ -189,6 +191,8 @@ const orderActions = (deps = {}) => {
     getModifierRelations: getModifierRelations(innerDeps),
     resetItem: resetItem(innerDeps),
     splitItems: splitItems(innerDeps),
+    getNewItems: getNewItems(innerDeps),
+    mapSubOrders: mapSubOrders(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/mapSubOrders.js

@@ -0,0 +1,17 @@
+module.exports = ({ actions }) =>
+  function mapSubOrders({ parentOrder, newSubOrders }) {
+    let subOrders = parentOrder.orders || [];
+
+    // reassign displayIds
+    subOrders = [...subOrders, ...newSubOrders].map((subOrder, index) => ({
+      ...subOrder,
+      displayId: `${parentOrder.displayId}-${index + 1}`,
+    }));
+
+    subOrders = actions.spreadModifiers({
+      parentOrder,
+      subOrders,
+    });
+
+    return subOrders;
+  };

package/lib/order/{syncSubOrderItemsFromParent.js → mergeItemsWithSubOrders.js}

@@ -1,5 +1,5 @@
 module.exports = () =>
-  function syncSubOrderItemsFromParent({ parentOrder }) {
+  function mergeItemsWithSubOrders({ parentOrder }) {
     const parentItems = parentOrder.items || [];
     const subOrders = [...(parentOrder.orders || [])].map(subOrder => {
       const items = subOrder.items

package/lib/order/splitByDepartments.js

@@ -1,14 +1,15 @@
 module.exports = ({ utils, _, actions, itemActions, modifierActions }) => {
   const { helpers } = utils;
 
+  const isSplitByPieces = splitUnit => splitUnit === 'pieces';
+
+  const isSplitByWeight = splitUnit => splitUnit === 'weight';
+
   const getDepartmentName = item => {
     const deps = itemActions.getDepartmentModifiers(item);
     return (deps.length && deps[0].name) || 'other';
   };
 
-  const isSplitByPieces = splitUnit => splitUnit === 'pieces';
-  const isSplitByWeight = splitUnit => splitUnit === 'weight';
-
   const joinItemQuantityById = orders =>
     orders.map(order => {
       const items = order.items.reduce((arr, item) => {
@@ -25,18 +26,15 @@ module.exports = ({ utils, _, actions, itemActions, modifierActions }) => {
       return { ...order, items };
     });
 
-  return function splitByDepartments(order) {
-    const { items } = order;
-    const itemsByDepartments = _.groupBy(items, getDepartmentName);
-    const orders = Object.entries(itemsByDepartments);
+  return function splitByDepartments({ parentOrder, newItems }) {
+    const itemsByDepartments = _.groupBy(newItems, getDepartmentName);
+    const itemGroups = Object.values(itemsByDepartments);
     let splitOrders = [];
 
-    orders.forEach(each => {
-      const [name, newItems] = each;
-      const create = actions.getSuborder({ order, name });
+    itemGroups.forEach(items => {
       // Assuming there is one department in the item
-      const department = itemActions.getDepartmentModifiers(newItems[0])[0];
-      const departmentName = getDepartmentName(newItems[0]);
+      const department = itemActions.getDepartmentModifiers(items[0])[0];
+      const departmentName = getDepartmentName(items[0]);
       const maxItems = modifierActions.getDepartmentMaxItems(department);
 
       const autoSplit = _.get(
@@ -67,12 +65,12 @@ module.exports = ({ utils, _, actions, itemActions, modifierActions }) => {
         return itemActions.getTotalQuantity(itemParam);
       };
 
-      const totalCount = getItemsTotalCount(newItems);
+      const totalCount = getItemsTotalCount(items);
 
       if (department && autoSplit && maxItems && totalCount > maxItems) {
         let newItemid = helpers.getObjectID();
 
-        newItems.forEach(newItem => {
+        items.forEach(newItem => {
           newItemid = helpers.getObjectID();
 
           for (let j = 0; j < newItem.quantity; j += 1) {
@@ -95,12 +93,15 @@ module.exports = ({ utils, _, actions, itemActions, modifierActions }) => {
             } else {
               newItemid = helpers.getObjectID();
               splitOrders.push(
-                create([{ ...item, _id: newItemid }], splitOrders.length + 1)
+                actions.createSubOrder({
+                  parentOrder,
+                  items: [{ ...item, _id: newItemid }],
+                })
               );
             }
           }
         });
-      } else splitOrders.push(create(newItems, splitOrders.length + 1));
+      } else splitOrders.push(actions.createSubOrder({ parentOrder, items }));
     });
 
     splitOrders = joinItemQuantityById(splitOrders);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.84",
+  "version": "1.0.86",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -51,5 +51,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "d15a98cdefcf27cdaf41a8096a6c6c7dcdfcc13f"
+  "gitHead": "feab9f47beb2312e3b82bae4eb2ec63f18d64be3"
 }

package/__TEST__/order/getSuborder.test.js

@@ -1,89 +0,0 @@
-const usePricing = require('../../index');
-const mockStores = require('../mocks/stores');
-const orderMock = require('../modifier/mocks/orderMock.json');
-
-const session = {
-  store: mockStores[0],
-};
-
-const pricingService = usePricing(session);
-
-const mockItem = {
-  location: {},
-  status: {
-    picked: {
-      value: false,
-      date: '',
-    },
-    paid: {
-      value: false,
-      date: '',
-    },
-    tracker: [],
-  },
-  name: 'Andre Pants 2',
-  description: 'Andre Pants 2',
-  pieces: 1,
-  modifiersTotalAmount: 0,
-  total: 2,
-  totalPaid: 0,
-  price: 2,
-  quantity: 1,
-  path: ',66da070aac2d4ae39904050f,66da131a81cf1303bc32a2c7,',
-  notes: [],
-  serial: null,
-  sku: 'AND-PAN2',
-  modifiers: [],
-  _id: '66ec759cd57e32c3455724a0',
-  weight: null,
-  properties: null,
-  hasInventory: true,
-  inventoryType: 'pull',
-  category: null,
-  priceLevels: [
-    {
-      value: 10,
-      tags: ['default'],
-    },
-    {
-      value: 2,
-      tags: ['vip'],
-    },
-    {
-      value: 10,
-      tags: ['default', 'press only'],
-    },
-    {
-      value: 2,
-      tags: ['vip', 'press only'],
-    },
-  ],
-  costLevels: [],
-  itemId: '66da11fdac2d4ae39904465e',
-  menuRuleId: '66da132381cf1303bc32a2c8',
-  __typename: 'OrderItem',
-  subTotals: {
-    _included: 0,
-    _xincluded: 0,
-    _direct: 0,
-    _xdirect: 0,
-    _simple: 2,
-    _actual: 2,
-  },
-};
-
-describe('Get sub order', () => {
-  test('Get a suborder with one item', () => {
-    const order = orderMock;
-    const create = pricingService.order.getSuborder({ order });
-    const newSubOrders = [create(order.items, 1)];
-    expect(newSubOrders).toHaveLength(1);
-  });
-  test('Get a suborder with multiple items', () => {
-    const order = orderMock;
-    const create = pricingService.order.getSuborder({ order });
-    order.items = [...order.items, mockItem];
-    const newSubOrders = [create(order.items, 2)];
-    expect(newSubOrders).toHaveLength(1);
-  });
-});

package/lib/order/createSuborder.js

@@ -1,17 +0,0 @@
-module.exports = ({ actions }) =>
-  function createSuborder(order) {
-    const create = actions.getSuborder({ order });
-    let subOrders = order.orders || [];
-    const newSubOrders = [create(order.items, 1)];
-    subOrders = [...subOrders, ...newSubOrders].map((subOrder, idx) => ({
-      ...subOrder,
-      displayId: `${order.displayId}-${idx + 1}`,
-    }));
-
-    subOrders = actions.spreadModifiers({
-      parentOrder: order,
-      subOrders,
-    });
-
-    return subOrders;
-  };

package/lib/order/getSuborder.js

@@ -1,36 +0,0 @@
-module.exports = ({ utils, _, settings }) => {
-  const orderSettings = _.get(settings, 'order');
-  const { helpers } = utils;
-
-  const getSubOrder =
-    ({ order }) =>
-    (items, index) => {
-      let displayId = '';
-      if (orderSettings.allowSuborder)
-        displayId = `${order.displayId}-${index}`;
-      else if (index === 1) displayId = order.displayId;
-
-      return {
-        ...order,
-        _id: helpers.getObjectID(),
-        displayId,
-        discount: 0,
-        tax: 0,
-        totalPaid: 0,
-        total: 0,
-        status: {
-          order: 'open',
-          delivery: order.status.delivery,
-          detailed: order.status.detailed,
-          fullyPaid: false,
-          fullyPicked: false,
-        },
-        parentId: orderSettings.allowSuborder ? order._id : null,
-        items,
-        modifiers: [],
-        notes: order.notes || [],
-      };
-    };
-
-  return getSubOrder;
-};