@darkpos/pricing 1.0.104 → 1.0.107

package/__TEST__/order/conditionsNotMet.test.js

@@ -1315,6 +1315,10 @@ describe('Conditions not met for the item', () => {
     expect(calculatedOrder.total).toBe(7.5);
     expect(calculatedOrder.items[0].total).toBe(7.5);
     expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(true);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(true);
+    expect(calculatedOrder.items[0].modifiers[0].properties.customerId).toBe(
+      '123456789'
+    );
   });
 
   test('Should mark modifier as not valid if customerTotalSales !== 0', () => {
@@ -1372,6 +1376,7 @@ describe('Conditions not met for the item', () => {
     expect(calculatedOrder.total).toBe(10);
     expect(calculatedOrder.items[0].total).toBe(10);
     expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(false);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(undefined);
   });
 
   test('Should mark modifier as valid if customerTotalVisits === 0', () => {
@@ -1429,6 +1434,10 @@ describe('Conditions not met for the item', () => {
     expect(calculatedOrder.total).toBe(7.5);
     expect(calculatedOrder.items[0].total).toBe(7.5);
     expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(true);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(true);
+    expect(calculatedOrder.items[0].modifiers[0].properties.customerId).toBe(
+      '123456789'
+    );
   });
 
   test('Should mark modifier as not valid if customerTotalVisits !== 0', () => {
@@ -1486,5 +1495,133 @@ describe('Conditions not met for the item', () => {
     expect(calculatedOrder.total).toBe(10);
     expect(calculatedOrder.items[0].total).toBe(10);
     expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(false);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(undefined);
+  });
+
+  test('Should mark modifier as not valid if there is no customer', () => {
+    const modifier = {
+      _id: '6819114c06c23d37c1f19412',
+      name: 'first order discount',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'customerTotalVisits',
+            value: 0,
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 25,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [],
+    };
+
+    let order = {
+      items: [item],
+    };
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+    });
+
+    expect(order.items[0].modifiers.length).toBe(1);
+
+    const calculatedOrder = pricingService.order.calculate(order);
+
+    expect(calculatedOrder.total).toBe(10);
+    expect(calculatedOrder.items[0].total).toBe(10);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(false);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(undefined);
+    expect(calculatedOrder.items[0].modifiers[0].properties).toBe(undefined);
+  });
+
+  test('Should mark modifier as valid if there is a customer, no matter is stats is undefined', () => {
+    const modifier = {
+      _id: '6819114c06c23d37c1f19412',
+      name: 'first order discount',
+      type: 'discount',
+      tags: ['default'],
+      direct: true,
+      conditions: {
+        valid: null,
+        rules: [
+          {
+            key: 'customerTotalVisits',
+            value: 0,
+            operand: '$eq',
+          },
+        ],
+      },
+      compute: {
+        type: 'percentage',
+        action: 'subtract',
+        amount: 25,
+      },
+    };
+
+    const item = {
+      _id: 'abc',
+      price: 10,
+      quantity: 1,
+      modifiers: [],
+    };
+
+    let order = {
+      items: [item],
+      customer: {
+        _id: 'abcd1234',
+      },
+    };
+
+    order = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+    });
+
+    expect(order.items[0].modifiers.length).toBe(1);
+
+    let calculatedOrder = pricingService.order.calculate(order);
+
+    expect(calculatedOrder.total).toBe(7.5);
+    expect(calculatedOrder.items[0].total).toBe(7.5);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(true);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(true);
+    expect(calculatedOrder.items[0].modifiers[0].properties.customerId).toBe(
+      'abcd1234'
+    );
+
+    calculatedOrder = pricingService.order.calculate({
+      ...calculatedOrder,
+      customer: {
+        _id: '11122555',
+        stats: {
+          totalVisits: 15,
+        },
+      },
+    });
+
+    expect(calculatedOrder.total).toBe(10);
+    expect(calculatedOrder.items[0].total).toBe(10);
+    expect(calculatedOrder.items[0].modifiers[0].conditions.valid).toBe(false);
+    expect(calculatedOrder.items[0].modifiers[0].locked).toBe(false);
+    expect(calculatedOrder.items[0].modifiers[0].properties.customerId).toBe(
+      undefined
+    );
   });
 });

package/__TEST__/order/order.test.js

@@ -1602,9 +1602,6 @@ describe('Order actions', () => {
     expect(subOrders[0].displayId).toBe('1-1');
     expect(subOrders[0].items.map(item => item.name)).toEqual([
       'Box Shirt - Fold',
-    ]);
-    expect(subOrders[1].displayId).toBe('1-2');
-    expect(subOrders[1].items.map(item => item.name)).toEqual([
       'Pants',
       'M-L 2pc Suit',
     ]);
@@ -3193,7 +3190,7 @@ describe('Order actions', () => {
   test('should return the latest location= assembled', () => {
     const status = {
       assembled: { location: '1', date: '2024-02-27T12:00:00Z' },
-      tracker: { location: 'Truck', date: '2024-02-26T12:00:00Z' },
+      tracker: [{ location: 'Truck', date: '2024-02-26T12:00:00Z' }],
       racked: { location: '%AB', date: '2024-02-25T15:00:00Z' },
     };
     expect(pricingService.order.getLastLocation({ status })).toEqual({
@@ -3207,7 +3204,7 @@ describe('Order actions', () => {
   test('should return the latest location= racked', () => {
     const status = {
       assembled: { location: '1', date: '2024-02-25T12:00:00Z' },
-      tracker: { location: 'Truck', date: '2024-02-26T12:00:00Z' },
+      tracker: [{ location: 'Truck', date: '2024-02-26T12:00:00Z' }],
       racked: { location: '%AB', date: '2024-02-27T15:00:00Z' },
     };
     expect(pricingService.order.getLastLocation({ status })).toEqual({
@@ -3221,7 +3218,7 @@ describe('Order actions', () => {
   test('should handle null values correctly and still return the latest location', () => {
     const status = {
       assembled: null,
-      tracker: { location: 'Truck', date: '2024-02-26T12:00:00Z' },
+      tracker: [{ location: 'Truck', date: '2024-02-26T12:00:00Z' }],
       racked: { location: '%AB', date: '2024-02-27T15:00:00Z' },
     };
     expect(pricingService.order.getLastLocation({ status })).toEqual({

package/__TEST__/order/split.test.js

@@ -37,12 +37,14 @@ describe('Auto Split', () => {
       _id: '123',
       itemId: '234',
       modifiers: [laundryModNoAutoSplit],
+      quantity: 1,
     };
 
     const item2 = {
       _id: '123',
       itemId: '234',
       modifiers: [dryCleaningModNoAutoSplit],
+      quantity: 1,
     };
 
     const item3 = {
@@ -70,7 +72,11 @@ describe('Auto Split', () => {
       },
     });
 
-    expect(subOrders.length).toEqual(3);
+    expect(subOrders.length).toEqual(1);
+    expect(subOrders[0].items.length).toEqual(3);
+    expect(subOrders[0].items[0].quantity).toEqual(2);
+    expect(subOrders[0].items[1].quantity).toEqual(1000);
+    expect(subOrders[0].items[2].quantity).toEqual(1000);
   });
 
   test('Auto split by department and Items Quantity', () => {
@@ -125,7 +131,7 @@ describe('Auto Split', () => {
       },
     });
 
-    expect(subOrders.length).toEqual(7);
+    expect(subOrders.length).toEqual(6);
   });
 
   test('Auto split by department and Items Pieces', () => {
@@ -180,7 +186,7 @@ describe('Auto Split', () => {
       },
     });
 
-    expect(subOrders.length).toEqual(12);
+    expect(subOrders.length).toEqual(11);
   });
 
   test('Auto split by department and Items Pieces 2', () => {
@@ -260,13 +266,13 @@ describe('Auto Split', () => {
       },
     });
 
-    expect(subOrders.length).toEqual(6);
+    expect(subOrders.length).toEqual(5);
     expect(subOrders[0].items[0].quantity).toEqual(3);
     expect(subOrders[1].items[0].quantity).toEqual(3);
     expect(subOrders[2].items[0].quantity).toEqual(3);
     expect(subOrders[3].items[0].quantity).toEqual(1);
     expect(subOrders[4].items[0].quantity).toEqual(5);
-    expect(subOrders[5].items[0].quantity).toEqual(1000);
+    expect(subOrders[4].items[1].quantity).toEqual(1000);
   });
 
   test('Auto split by department and Items Weight', () => {
@@ -395,4 +401,283 @@ describe('Auto Split', () => {
     expect(subOrders[0].items[1].modifiers[0]._id).toEqual('234');
     expect(subOrders[0].items[1].modifiers[1]._id).toEqual('456');
   });
+
+  test('Auto split by department and Items Weight 0 (unlimited)', () => {
+    const { autoSplit } = pricingService.order;
+
+    const laundryModMaxItems = {
+      ...laundryModNoAutoSplit,
+      properties: {
+        department: {
+          autoSplit: true,
+          maxItems: 0,
+          splitUnit: 'weight',
+        },
+      },
+    };
+
+    const item1 = {
+      _id: '123',
+      itemId: '234',
+      modifiers: [laundryModMaxItems],
+      quantity: 1,
+      pieces: 2,
+      weight: 25,
+    };
+
+    const item2 = {
+      _id: '322',
+      itemId: '4555',
+      modifiers: [laundryModMaxItems],
+      quantity: 1,
+      pieces: 2,
+      weight: 25,
+    };
+
+    const subOrders = autoSplit({
+      parentOrder: {
+        items: [item1, item2],
+        status: {},
+        modifiers: [],
+        displayId: 1,
+      },
+    });
+
+    expect(subOrders.length).toEqual(1);
+    expect(subOrders[0].items[0].quantity).toEqual(1);
+    expect(subOrders[0].items[0].weight).toEqual(25);
+
+    expect(subOrders[0].items[1].quantity).toEqual(1);
+    expect(subOrders[0].items[1].weight).toEqual(25);
+  });
+
+  test('Should keep both the parent and the related items in a single order. (keepRelatedItems=true)', () => {
+    const tailoringModifier = {
+      _id: '686d62bee0f59b1de5d93b2d',
+      attributes: ['department'],
+      modifierId: '67fea241af24e570c032b339',
+      name: 'Tailoring',
+      tags: ['default'],
+      code: 'T',
+      properties: {
+        group: null,
+        department: {
+          tagSize: null,
+          customerTagsExtend: null,
+          autoSplit: true,
+        },
+      },
+      conditions: {
+        valid: true,
+      },
+    };
+
+    const dtModifier = {
+      _id: '686d62bee0f59b1de5d93b2f',
+      attributes: ['department'],
+      modifierId: '686c4033399a3a7376b7ec3a',
+      _parentId: null,
+      locked: false,
+      name: 'D + T',
+      sku: '',
+      description: '',
+      group: '',
+      type: '',
+      tags: ['default'],
+      order: 0,
+      included: false,
+      direct: true,
+      hidden: false,
+      print: true,
+      required: false,
+      recommended: false,
+      default: false,
+      code: 'DT',
+      properties: {
+        subscription: {},
+        override: {},
+        group: {
+          items: [],
+          modifiers: [],
+        },
+        department: {
+          tagSize: 'small',
+          splitUnit: 'quantity',
+          maxItems: '',
+          autoSplit: true,
+          keepRelatedItems: true,
+        },
+        sort: null,
+      },
+      _computed: {
+        amount: 0,
+        description: 'D + T',
+      },
+      conditions: {
+        valid: true,
+      },
+      compute: null,
+      _createdAt: '2025-07-07T21:46:27.393Z',
+      _updatedAt: '2025-07-08T15:48:47.145Z',
+      __typename: 'Modifier',
+    };
+
+    const parentOrder = {
+      _id: '686d62ace0f59b1de5d93b27',
+
+      items: [
+        {
+          name: 'Jacket Zipper Long',
+          modifiers: [tailoringModifier],
+          _id: '686d62bee0f59b1de5d93b2c',
+          weight: 0,
+          properties: {
+            relatedItem: true,
+            parentItemId: '67fea241af24e570c032b319',
+            parentId: '686d62b3e0f59b1de5d93b28',
+            includeParent: true,
+          },
+        },
+        {
+          name: "2pc Men's Suit",
+          modifiers: [dtModifier],
+          _id: '686d62b3e0f59b1de5d93b28',
+          pieces: 2,
+          quantity: 1,
+          weight: 0,
+          properties: {},
+        },
+      ],
+      modifiers: [],
+      status: {},
+    };
+
+    const subOrders = pricingService.order.autoSplit({
+      parentOrder,
+    });
+
+    expect(subOrders.length).toBe(1);
+    expect(subOrders[0].items.length).toBe(2);
+  });
+
+  test('Should split the parent and the related items in different orders. (keepRelatedItems=false)', () => {
+    const tailoringModifier = {
+      _id: '686d62bee0f59b1de5d93b2d',
+      attributes: ['department'],
+      modifierId: '67fea241af24e570c032b339',
+      name: 'Tailoring',
+      tags: ['default'],
+      code: 'T',
+      properties: {
+        group: null,
+        department: {
+          tagSize: null,
+          customerTagsExtend: null,
+          autoSplit: true,
+        },
+      },
+      conditions: {
+        valid: true,
+      },
+    };
+
+    const dtModifier = {
+      _id: '686d62bee0f59b1de5d93b2f',
+      attributes: ['department'],
+      modifierId: '686c4033399a3a7376b7ec3a',
+      _parentId: null,
+      locked: false,
+      name: 'D + T',
+      sku: '',
+      description: '',
+      group: '',
+      type: '',
+      tags: ['default'],
+      order: 0,
+      included: false,
+      direct: true,
+      hidden: false,
+      print: true,
+      required: false,
+      recommended: false,
+      default: false,
+      code: 'DT',
+      properties: {
+        subscription: {},
+        override: {},
+        group: {
+          items: [],
+          modifiers: [],
+        },
+        department: {
+          tagSize: 'small',
+          splitUnit: 'quantity',
+          maxItems: '',
+          autoSplit: true,
+          keepRelatedItems: false,
+        },
+        sort: null,
+      },
+      _computed: {
+        amount: 0,
+        description: 'D + T',
+      },
+      conditions: {
+        valid: true,
+      },
+      compute: null,
+      _createdAt: '2025-07-07T21:46:27.393Z',
+      _updatedAt: '2025-07-08T15:48:47.145Z',
+      __typename: 'Modifier',
+    };
+
+    const parentOrder = {
+      _id: '686d62ace0f59b1de5d93b27',
+
+      items: [
+        {
+          name: 'Jacket Zipper Long',
+          modifiers: [tailoringModifier],
+          _id: '686d62bee0f59b1de5d93b2c',
+          weight: 0,
+          properties: {
+            relatedItem: true,
+            parentItemId: '67fea241af24e570c032b319',
+            parentId: '686d62b3e0f59b1de5d93b28',
+            includeParent: true,
+          },
+        },
+        {
+          name: "2pc Men's Suit",
+          modifiers: [dtModifier],
+          _id: '686d62b3e0f59b1de5d93b28',
+          pieces: 2,
+          quantity: 1,
+          weight: 0,
+          properties: {},
+        },
+
+        {
+          name: 'other item',
+          modifiers: [],
+          _id: '12356487',
+          pieces: 2,
+          quantity: 1,
+          weight: 0,
+          properties: {},
+        },
+      ],
+      modifiers: [],
+      status: {},
+    };
+
+    const subOrders = pricingService.order.autoSplit({
+      parentOrder,
+    });
+
+    expect(subOrders.length).toBe(3);
+    expect(subOrders[0].items.length).toBe(1);
+    expect(subOrders[1].items.length).toBe(1);
+    expect(subOrders[2].items.length).toBe(1);
+  });
 });

package/lib/item/calculate.js

@@ -12,18 +12,7 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
     const isPrepay = opts.isPrepay || false;
     const startRequestDate = opts.startRequestDate || null;
     const endRequestDate = opts.endRequestDate || null;
-
-    let customerTotalVisits = 0;
-    let customerTotalSales = 0;
-
-    if (
-      opts.customer &&
-      typeof opts.customer !== 'string' &&
-      opts.customer.stats
-    ) {
-      customerTotalVisits = opts.customer.stats.totalVisits || 0;
-      customerTotalSales = opts.customer.stats.totalSales || 0;
-    }
+    const customer = opts.customer || null;
 
     const lockPaymentModifiers = !!opts.lockPaymentModifiers;
     const allItems = Array.isArray(opts.items) ? opts.items : [];
@@ -56,16 +45,21 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
     subTotals._simple = math.mul(price, quantity);
 
     const modifiers = [];
-    const { modifiers: itemModifiersPrev = [] } =
+    let { modifiers: itemModifiersPrev = [] } =
       actions.removeModifiersByQuantity(item);
 
+    itemModifiersPrev = modifierActions.unlockCustomerStatsModifiers({
+      modifiers: itemModifiersPrev,
+      customer,
+    });
+
     const itemModifiers = [...itemModifiersPrev].filter(
       mod =>
         !modifierActions.isCalculatedPaymentModifier(mod) ||
         modifierActions.isLocked(mod)
     );
 
-    const validatedModifiers = actions.validateModifiers({
+    let validatedModifiers = actions.validateModifiers({
       item,
       itemModifiers,
       startRequestDate,
@@ -74,8 +68,12 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
       paymentMethod,
       paymentType,
       isPrepay,
-      customerTotalVisits,
-      customerTotalSales,
+      customer,
+    });
+
+    validatedModifiers = modifierActions.lockCustomerStatsModifiers({
+      modifiers: validatedModifiers,
+      customer,
     });
 
     const modifiersToCompute = validatedModifiers.filter(

package/lib/item/getSplitDepartment.js

@@ -0,0 +1,23 @@
+module.exports = ({ actions, modifierActions }) =>
+  function getSplitDepartment({ items, item }) {
+    if (actions.isRelatedItem(item)) {
+      const parentItem = actions.getParentItem(items, item);
+
+      if (parentItem) {
+        const parentDeps = actions.getDepartmentModifiers(parentItem);
+        if (
+          parentDeps.length &&
+          modifierActions.isSplitDepartment(parentDeps[0]) &&
+          modifierActions.isKeepRelatedItems(parentDeps[0])
+        )
+          return parentDeps[0].name;
+      }
+    }
+
+    const deps = actions.getDepartmentModifiers(item);
+
+    if (deps.length && modifierActions.isSplitDepartment(deps[0]))
+      return deps[0].name;
+
+    return 'other';
+  };

package/lib/item/index.js

@@ -69,6 +69,7 @@ const validateModifiers = require('./validateModifiers');
 const adjustNegativeTotal = require('./adjustNegativeTotal');
 const applyNotesOverridesToItem = require('./applyNotesOverridesToItem');
 const getModifiersToNotCompute = require('./getModifiersToNotCompute');
+const getSplitDepartment = require('./getSplitDepartment');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -151,6 +152,7 @@ const itemActions = (deps = {}) => {
     adjustNegativeTotal: adjustNegativeTotal(innerDeps),
     applyNotesOverridesToItem: applyNotesOverridesToItem(innerDeps),
     getModifiersToNotCompute: getModifiersToNotCompute(innerDeps),
+    getSplitDepartment: getSplitDepartment(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/validateModifiers.js

@@ -8,8 +8,7 @@ module.exports = ({ modifierActions }) =>
     paymentMethod,
     paymentType,
     isPrepay,
-    customerTotalVisits,
-    customerTotalSales,
+    customer,
   }) {
     const validatedModifiers = [];
     const firstValidatedModifiers = itemModifiers.map(each =>
@@ -21,8 +20,7 @@ module.exports = ({ modifierActions }) =>
         paymentMethod,
         paymentType,
         isPrepay,
-        customerTotalVisits,
-        customerTotalSales,
+        customer,
       })
     );
 

package/lib/modifier/areConditionsMet.js

@@ -1,4 +1,15 @@
 module.exports = ({ actions, utils }) => {
+  const getCustomerStat = (customer, key) => {
+    if (
+      !customer ||
+      !customer.stats ||
+      typeof customer.stats[key] !== 'number'
+    ) {
+      return 0;
+    }
+    return customer.stats[key];
+  };
+
   const modifierConditionPass = (
     modifier,
     {
@@ -9,8 +20,7 @@ module.exports = ({ actions, utils }) => {
       paymentMethod,
       paymentType,
       isPrepay,
-      customerTotalVisits,
-      customerTotalSales,
+      customer,
     }
   ) =>
     modifier.conditions && Array.isArray(modifier.conditions.rules)
@@ -86,14 +96,16 @@ module.exports = ({ actions, utils }) => {
                 condition.operand
               );
             case 'customerTotalVisits':
+              if (!actions.isValidCustomer(customer)) return false;
               return actions.validateNumberCondition(
-                customerTotalVisits,
+                getCustomerStat(customer, 'totalVisits'),
                 condition.value,
                 condition.operand
               );
             case 'customerTotalSales':
+              if (!actions.isValidCustomer(customer)) return false;
               return actions.validateNumberCondition(
-                customerTotalSales,
+                getCustomerStat(customer, 'totalSales'),
                 condition.value,
                 condition.operand
               );
@@ -138,8 +150,7 @@ module.exports = ({ actions, utils }) => {
       paymentMethod,
       paymentType,
       isPrepay,
-      customerTotalVisits,
-      customerTotalSales,
+      customer,
     } = opts;
     return (
       modifier &&
@@ -151,8 +162,7 @@ module.exports = ({ actions, utils }) => {
         paymentMethod,
         paymentType,
         isPrepay,
-        customerTotalVisits,
-        customerTotalSales,
+        customer,
       })
     );
   }

package/lib/modifier/index.js

@@ -167,6 +167,15 @@ const isNotesOverride = require('./isNotesOverride');
 const isOverrideSubtotal = require('./isOverrideSubtotal');
 const validatePaymentCondition = require('./validatePaymentCondition');
 const createManualModifier = require('./createManualModifier');
+const isCustomerStatsModifier = require('./isCustomerStatsModifier');
+const isTotalSalesModifier = require('./isTotalSalesModifier');
+const isTotalVisitsModifier = require('./isTotalVisitsModifier');
+const isValidCustomer = require('./isValidCustomer');
+const lockCustomerStatsModifiers = require('./lockCustomerStatsModifiers');
+const unlockCustomerStatsModifiers = require('./unlockCustomerStatsModifiers');
+const isAutoSplit = require('./isAutoSplit');
+const isKeepRelatedItems = require('./isKeepRelatedItems');
+const isSplitDepartment = require('./isSplitDepartment');
 
 const modifierActions = (deps = {}) => {
   const actions = {};
@@ -347,6 +356,15 @@ const modifierActions = (deps = {}) => {
     isOverrideSubtotal: isOverrideSubtotal(innerDeps),
     validatePaymentCondition: validatePaymentCondition(innerDeps),
     createManualModifier: createManualModifier(innerDeps),
+    isCustomerStatsModifier: isCustomerStatsModifier(innerDeps),
+    isTotalSalesModifier: isTotalSalesModifier(innerDeps),
+    isTotalVisitsModifier: isTotalVisitsModifier(innerDeps),
+    isValidCustomer: isValidCustomer(innerDeps),
+    lockCustomerStatsModifiers: lockCustomerStatsModifiers(innerDeps),
+    unlockCustomerStatsModifiers: unlockCustomerStatsModifiers(innerDeps),
+    isAutoSplit: isAutoSplit(innerDeps),
+    isKeepRelatedItems: isKeepRelatedItems(innerDeps),
+    isSplitDepartment: isSplitDepartment(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/modifier/isAutoSplit.js

@@ -0,0 +1,4 @@
+module.exports = ({ _ }) =>
+  function isAutoSplit(modifier) {
+    return _.get(modifier || {}, 'properties.department.autoSplit', false);
+  };

package/lib/modifier/isCustomerStatsModifier.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function isCustomerStatModifier(modifier) {
+    return (
+      actions.isTotalSalesModifier(modifier) ||
+      actions.isTotalVisitsModifier(modifier)
+    );
+  };

package/lib/modifier/isKeepRelatedItems.js

@@ -0,0 +1,8 @@
+module.exports = ({ _ }) =>
+  function isAutoSplit(modifier) {
+    return _.get(
+      modifier || {},
+      'properties.department.keepRelatedItems',
+      false
+    );
+  };

package/lib/modifier/isSplitDepartment.js

@@ -0,0 +1,5 @@
+module.exports = ({ actions }) =>
+  function isSplitDepartment(modifier) {
+    if (!modifier || !actions.isDepartment(modifier)) return false;
+    return actions.isValid(modifier) && actions.isAutoSplit(modifier);
+  };

package/lib/modifier/isTotalSalesModifier.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function isPaymentTypeModifier(modifier) {
+    return !!(
+      modifier &&
+      modifier.conditions &&
+      Array.isArray(modifier.conditions.rules) &&
+      modifier.conditions.rules.some(
+        condition => condition.key === 'customerTotalSales'
+      )
+    );
+  };

package/lib/modifier/isTotalVisitsModifier.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function isTotalVisitsModifier(modifier) {
+    return !!(
+      modifier &&
+      modifier.conditions &&
+      Array.isArray(modifier.conditions.rules) &&
+      modifier.conditions.rules.some(
+        condition => condition.key === 'customerTotalVisits'
+      )
+    );
+  };

package/lib/modifier/isValidCustomer.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isValid(customer) {
+    return customer && typeof customer !== 'string' && customer._id;
+  };

package/lib/modifier/lockCustomerStatsModifiers.js

@@ -0,0 +1,22 @@
+module.exports = ({ actions }) =>
+  function lockCustomerStatsModifiers({ modifiers, customer }) {
+    if (!Array.isArray(modifiers)) return [];
+    return modifiers.map(valMod => {
+      if (
+        actions.isValidCustomer(customer) &&
+        actions.isCustomerStatsModifier(valMod) &&
+        actions.isValid(valMod)
+      ) {
+        return {
+          ...valMod,
+          locked: true,
+          properties: {
+            ...(valMod.properties || {}),
+            customerId: customer._id,
+          },
+        };
+      }
+
+      return valMod;
+    });
+  };

package/lib/modifier/unlockCustomerStatsModifiers.js

@@ -0,0 +1,23 @@
+module.exports = ({ actions }) =>
+  function unlockCustomerStatsModifiers({ modifiers, customer }) {
+    if (!Array.isArray(modifiers)) return [];
+    return modifiers.map(valMod => {
+      if (
+        actions.isValidCustomer(customer) &&
+        actions.isCustomerStatsModifier(valMod) &&
+        actions.isLocked(valMod) &&
+        valMod.properties.customerId !== customer._id
+      ) {
+        return {
+          ...valMod,
+          locked: false,
+          properties: {
+            ...(valMod.properties || {}),
+            customerId: undefined,
+          },
+        };
+      }
+
+      return valMod;
+    });
+  };

package/lib/order/getLastLocation.js

@@ -1,11 +1,20 @@
-module.exports = () =>
-  function getLastLocation(order) {
+module.exports = () => {
+  const sortByDateAsc = (obj1, obj2) =>
+    new Date(obj1.date) - new Date(obj2.date);
+
+  return function getLastLocation(order) {
     if (!order || !order.status) return null;
 
-    const { assembled = {}, tracker = {}, racked = {} } = order.status;
+    const { assembled = {}, tracker = [], racked = {} } = order.status;
+    const trackerArr = (Array.isArray(tracker) ? tracker : [tracker]).filter(
+      Boolean
+    );
+    trackerArr.sort(sortByDateAsc);
 
     let latestLocation =
-      tracker && tracker.date ? { ...tracker, isTracker: true } : {};
+      trackerArr.length > 0
+        ? { ...trackerArr[trackerArr.length - 1], isTracker: true }
+        : {};
 
     if (
       assembled &&
@@ -26,3 +35,4 @@ module.exports = () =>
 
     return Object.keys(latestLocation).length !== 0 ? latestLocation : null;
   };
+};

package/lib/order/splitByDepartments.js

@@ -13,11 +13,6 @@ module.exports = ({
 
   const isSplitByWeight = splitUnit => splitUnit === 'weight';
 
-  const getDepartmentName = item => {
-    const deps = itemActions.getDepartmentModifiers(item);
-    return (deps.length && deps[0].name) || 'other';
-  };
-
   const joinItemQuantityById = orders =>
     orders.map(order => {
       const items = order.items.reduce((arr, item) => {
@@ -37,8 +32,10 @@ module.exports = ({
   const getDepartmentSchedules = department => {
     if (!department) return null;
     const allSchedules = _.get(settings, 'order.schedules', []);
-    return allSchedules.filter(item =>
-      item.departments.some(dep => dep._id === department.modifierId)
+    return allSchedules.filter(
+      item =>
+        Array.isArray(item.departments) &&
+        item.departments.some(dep => dep._id === department.modifierId)
     );
   };
 
@@ -46,7 +43,15 @@ module.exports = ({
     parentOrder: parentOrderParam,
     newItems,
   }) {
-    const itemsByDepartments = _.groupBy(newItems, getDepartmentName);
+    const sortedItems = [...newItems].sort((a, b) => {
+      const aIsRelated = itemActions.isRelatedItem(a);
+      const bIsRelated = itemActions.isRelatedItem(b);
+      return Number(aIsRelated) - Number(bIsRelated);
+    });
+
+    const itemsByDepartments = _.groupBy(sortedItems, item =>
+      itemActions.getSplitDepartment({ items: sortedItems, item })
+    );
     const itemGroups = Object.values(itemsByDepartments);
     let splitOrders = [];
     const defaultEndDate = storeActions.pickEndDate();
@@ -58,7 +63,10 @@ module.exports = ({
     itemGroups.forEach(items => {
       // Assuming there is one department in the item
       const department = itemActions.getDepartmentModifiers(items[0])[0];
-      const departmentName = getDepartmentName(items[0]);
+      const departmentName = itemActions.getSplitDepartment({
+        items: sortedItems,
+        item: items[0],
+      });
       const maxItems = modifierActions.getDepartmentMaxItems(department);
       const departmentSchedules = getDepartmentSchedules(department);
       let parentOrder = { ...parentOrderParam };
@@ -74,11 +82,7 @@ module.exports = ({
         });
       }
 
-      const autoSplit = _.get(
-        department || {},
-        'properties.department.autoSplit',
-        false
-      );
+      const autoSplit = modifierActions.isAutoSplit(department);
 
       const splitUnit = _.get(
         department || {},
@@ -123,7 +127,11 @@ module.exports = ({
                 newOrder.items &&
                 getItemsTotalCount(newOrder.items) + totalCountPerItem <=
                   maxItems &&
-                departmentName === getDepartmentName(newOrder.items[0])
+                departmentName ===
+                  itemActions.getSplitDepartment({
+                    items: sortedItems,
+                    item: items[0],
+                  })
             );
             if (index > -1) {
               splitOrders[index].items.push(item);
@@ -138,7 +146,9 @@ module.exports = ({
             }
           }
         });
-      } else splitOrders.push(actions.createSubOrder({ parentOrder, items }));
+      } else {
+        splitOrders.push(actions.createSubOrder({ parentOrder, items }));
+      }
     });
 
     splitOrders = joinItemQuantityById(splitOrders);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.104",
+  "version": "1.0.107",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -54,5 +54,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "0a74400677d6852460e9a7773a3e6480912ad8b3"
+  "gitHead": "16a66c27afee8501a123219c6653b59800654b81"
 }