@darkpos/pricing 1.0.44 → 1.0.45

package/__TEST__/item/getItemsModifierDescription.test.js

@@ -1,31 +1,52 @@
-const _ = require('lodash');
-const getItemModifiersDescriptionFunction = require('../../lib/item/getItemModifiersDescription');
-
-describe('getItemModifiersDescription Function', () => {
-  const modifierActions = {
-    isHidden: jest.fn(),
-    isAmountOverride: jest.fn(),
-    isDepartment: jest.fn(),
-    isDirect: jest.fn(),
-    isGroupOfValues: jest.fn(),
-    getSelectedValues: jest.fn(),
-    getGroupedModifiers: jest.fn(),
-    getNotesToModifierTags: jest.fn(),
-    isValid: jest.fn(),
-  };
-
-  const settings = {
-    order: {
-      groupModifiers: false,
+const usePricing = require('../../lib/index');
+
+const pricingService = usePricing();
+
+const { getItemModifiersDescription } = pricingService.item;
+const mockModifier = {
+  _id: '67106323db3c71afb52b07b7',
+  attributes: ['override'],
+  modifierId: '66e0a6c2f0f1df1a20a00bbf',
+  _parentId: null,
+  locked: false,
+  name: 'ItemsPriceManual',
+  sku: '',
+  description: '',
+  group: '',
+  type: '',
+  tags: ['default'],
+  order: 0,
+  included: false,
+  direct: true,
+  hidden: false,
+  print: true,
+  required: false,
+  recommended: false,
+  default: false,
+  code: '',
+  properties: {
+    override: {
+      field: 'price',
+      type: 'manual',
     },
-  };
-
-  const getItemModifiersDescription = getItemModifiersDescriptionFunction({
-    modifierActions,
-    _,
-    settings,
-  });
-
+    group: {
+      modifiers: [],
+      items: [],
+    },
+    sort: null,
+  },
+  _computed: {
+    amount: 0,
+    description: 'ItemsPriceManual ($0.00)',
+  },
+  addModifiers: [],
+  delModifiers: [],
+  conditions: null,
+  compute: null,
+  _createdAt: '2024-10-17T01:12:34.370Z',
+  _updatedAt: '2024-10-17T01:12:34.370Z',
+};
+describe('getItemModifiersDescription Function', () => {
   beforeEach(() => {
     jest.clearAllMocks();
   });
@@ -39,51 +60,32 @@ describe('getItemModifiersDescription Function', () => {
     const item = {
       modifiers: [
         {
+          ...mockModifier,
           _id: 'mod1',
           name: 'Modifier 1',
           _computed: { description: 'Desc 1' },
         },
-        { _id: 'mod2', name: 'Modifier 2' },
+        { ...mockModifier, hidden: true, _id: 'mod2', name: 'Modifier 2' },
       ],
     };
 
-    modifierActions.isHidden
-      .mockReturnValueOnce(false)
-      .mockReturnValueOnce(false);
-    modifierActions.isAmountOverride
-      .mockReturnValueOnce(false)
-      .mockReturnValueOnce(false);
-    modifierActions.isDepartment
-      .mockReturnValueOnce(false)
-      .mockReturnValueOnce(false);
-    modifierActions.isDirect
-      .mockReturnValueOnce(true)
-      .mockReturnValueOnce(true);
-    modifierActions.isGroupOfValues
-      .mockReturnValueOnce(false)
-      .mockReturnValueOnce(false);
-    modifierActions.isValid
-      .mockReturnValueOnce(false)
-      .mockReturnValueOnce(false);
-    modifierActions.getNotesToModifierTags.mockReturnValueOnce([
-      { label: 'Desc 1', value: 'mod1' },
-    ]);
-
     const result = getItemModifiersDescription(item);
 
-    expect(result).toEqual([{ label: 'Desc 1', value: 'mod1' }]);
-
-    expect(modifierActions.isHidden).toHaveBeenCalledTimes(2);
-    expect(modifierActions.isValid).toHaveBeenCalledTimes(2);
-    expect(modifierActions.isAmountOverride).toHaveBeenCalledTimes(0);
-    expect(modifierActions.isDepartment).toHaveBeenCalledTimes(0);
-    expect(modifierActions.isDirect).toHaveBeenCalledTimes(0);
+    expect(result).toEqual([
+      {
+        label: 'Desc 1',
+        value: 'mod1',
+        data: item.modifiers[0],
+        quantity: 1,
+      },
+    ]);
   });
 
   test('should handle selected override options in the modifier', () => {
     const item = {
       modifiers: [
         {
+          ...mockModifier,
           _id: 'mod1',
           name: 'Modifier 1',
           compute: { amount: 100 },
@@ -92,19 +94,6 @@ describe('getItemModifiersDescription Function', () => {
       ],
     };
 
-    modifierActions.isHidden.mockReturnValueOnce(false);
-    modifierActions.isValid.mockReturnValueOnce(false);
-    modifierActions.isAmountOverride.mockReturnValueOnce(false);
-    modifierActions.isDepartment.mockReturnValueOnce(false);
-    modifierActions.isDirect.mockReturnValueOnce(true);
-    modifierActions.getNotesToModifierTags.mockReturnValueOnce([
-      {
-        label: 'Modifier 1 100 kg',
-        value: 'mod1',
-        data: item.modifiers[0],
-        quantity: 0,
-      },
-    ]);
     const result = getItemModifiersDescription(item);
 
     expect(result).toEqual([
@@ -118,9 +107,16 @@ describe('getItemModifiersDescription Function', () => {
   });
 
   test('should group modifiers when groupModifiers setting is true', () => {
+    const pricingService2 = usePricing({
+      store: { _settings: { order: { groupModifiers: true } } },
+    });
+
+    const { getItemModifiersDescription: getItemModifiersDescription2 } =
+      pricingService2.item;
     const item = {
       modifiers: [
         {
+          ...mockModifier,
           _id: 'mod1',
           name: 'Modifier 1',
           _computed: { description: 'Desc 1' },
@@ -128,21 +124,15 @@ describe('getItemModifiersDescription Function', () => {
       ],
     };
 
-    settings.order.groupModifiers = true;
-    modifierActions.isHidden.mockReturnValueOnce(false);
-    modifierActions.isValid.mockReturnValueOnce(false);
-    modifierActions.isAmountOverride.mockReturnValueOnce(false);
-    modifierActions.isDepartment.mockReturnValueOnce(false);
-    modifierActions.isDirect.mockReturnValueOnce(true);
-    modifierActions.getGroupedModifiers.mockReturnValueOnce([
-      { label: 'Grouped Modifier', value: 'mod1' },
-    ]);
-    modifierActions.getNotesToModifierTags.mockReturnValueOnce([
-      { label: 'Grouped Modifier', value: 'mod1' },
-    ]);
+    const result = getItemModifiersDescription2(item);
 
-    const result = getItemModifiersDescription(item);
-
-    expect(result).toEqual([{ label: 'Grouped Modifier', value: 'mod1' }]);
+    expect(result).toEqual([
+      {
+        label: '1 Desc 1',
+        value: 'mod1',
+        quantity: 1,
+        data: item.modifiers[0],
+      },
+    ]);
   });
 });

package/__TEST__/mocks/scripts/calculate-partially-paid/index.js

@@ -9,8 +9,8 @@ const inputItems = require('../../partially-paid/input-items.json');
 const pricingService = usePricing();
 
 const paymentModifiers = orderModifiers.map(orderMod =>
-  pricingService.modifier.createPaymentModifier({
-    modifier: orderMod,
+  pricingService.modifier.duplicate({
+    orderMod,
     items: inputItems,
   })
 );

package/__TEST__/mocks/scripts/calculate-unpaid/index.js

@@ -9,8 +9,8 @@ const inputItems = require('../../unpaid/input-items.json');
 const pricingService = usePricing();
 
 const paymentModifiers = orderModifiers.map(orderMod =>
-  pricingService.modifier.createPaymentModifier({
-    modifier: orderMod,
+  pricingService.modifier.duplicate({
+    ...orderMod,
     items: inputItems,
   })
 );

package/__TEST__/order/manualSplit.test.js

@@ -0,0 +1,104 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+describe('manualSplit', () => {
+  test('should split item by quantity between suborders', () => {
+    const currentOrder = { items: [{ _id: 'item1', quantity: 2 }] };
+    const subOrders = [
+      { items: [{ _id: 'item1', quantity: 2 }] },
+      { items: [] },
+    ];
+
+    const result = pricingService.order.manualSplit(
+      { orderIndex: 0, itemIndex: 0 },
+      1,
+      currentOrder,
+      subOrders,
+      'item1',
+      true
+    );
+
+    expect(result[0].items[0].quantity).toBe(1); // Decreases quantity in original order
+    expect(result[1].items[0].quantity).toBe(1); // Adds quantity to destination
+  });
+  test('should remove item if quantity becomes zero', () => {
+    const currentOrder = { items: [{ _id: 'item1', quantity: 1 }] };
+    const subOrders = [
+      { items: [{ _id: 'item1', quantity: 1 }] },
+      { items: [] },
+    ];
+
+    const result = pricingService.order.manualSplit(
+      { orderIndex: 0, itemIndex: 0 },
+      1,
+      currentOrder,
+      subOrders,
+      'item1',
+      true
+    );
+
+    expect(result[0].items.length).toBe(0); // Removes item from original order
+    expect(result[1].items[0].quantity).toBe(1); // Adds to destination
+  });
+
+  test('should call manualSplitByQuantity if splitQuantity is true', () => {
+    const currentOrder = { items: [{ _id: 'item1', quantity: 2 }] };
+    const subOrders = [
+      { items: [{ _id: 'item1', quantity: 2 }] },
+      { items: [] },
+    ];
+
+    const result = pricingService.order.manualSplit(
+      { orderIndex: 0, itemIndex: 0 },
+      1,
+      currentOrder,
+      subOrders,
+      'item1',
+      true
+    );
+
+    expect(result[0].items[0].quantity).toBe(1); // Split by quantity
+    expect(result[1].items[0].quantity).toBe(1);
+  });
+
+  test('should move item to destination subOrder if splitQuantity is false', () => {
+    const currentOrder = { items: [{ _id: 'item1', quantity: 2 }] };
+    const subOrders = [
+      { items: [{ _id: 'item1', quantity: 2 }] },
+      { items: [] },
+    ];
+
+    const result = pricingService.order.manualSplit(
+      { orderIndex: 0, itemIndex: 0 },
+      1,
+      currentOrder,
+      subOrders,
+      'item1',
+      false
+    );
+
+    expect(result[0].items.length).toBe(0); // Removes item from original suborder
+    expect(result[1].items[0]._id).toBe('item1'); // Moves item to destination
+  });
+
+  test('should return subOrders unchanged if indices are invalid', () => {
+    const subOrders = [{ items: [] }, { items: [] }];
+
+    const result = pricingService.order.manualSplit(
+      { orderIndex: null, itemIndex: null },
+      1,
+      {},
+      subOrders,
+      'item1',
+      false
+    );
+
+    expect(result).toEqual(subOrders); // No change
+  });
+});