@openmrs/esm-laboratory-app 1.2.1-pre.739 → 1.2.1-pre.745

package/src/components/orders-table/orders-data-table.component.tsx

@@ -1,4 +1,4 @@
-import React, { useCallback, useMemo, useState } from 'react';
+import React, { useMemo, useState } from 'react';
 import {
   DataTable,
   DataTableSkeleton,
@@ -22,67 +22,152 @@ import {
   TableToolbarSearch,
   Tile,
 } from '@carbon/react';
-import { ExtensionSlot, formatDate, parseDate, showModal, usePagination } from '@openmrs/esm-framework';
+import {
+  ExtensionSlot,
+  formatDate,
+  parseDate,
+  type Patient,
+  showModal,
+  useConfig,
+  usePagination,
+} from '@openmrs/esm-framework';
 import { useTranslation } from 'react-i18next';
-import { type Order } from '@openmrs/esm-patient-common-lib';
-import type { FulfillerStatus, OrdersDataTableProps } from '../../types';
-import { useLabOrders, useSearchGroupedResults } from '../../laboratory-resource';
+import { type Order, type FulfillerStatus } from '@openmrs/esm-patient-common-lib';
+import { type FlattenedOrder, type OrderAction } from '../../types';
+import { useLabOrders } from '../../laboratory-resource';
 import { OrdersDateRangePicker } from './orders-date-range-picker.component';
 import ListOrderDetails from './list-order-details.component';
 import styles from './orders-data-table.scss';
+import { type Config } from '../../config-schema';
+
+const labTableColumnSpec = {
+  name: {
+    // t('patient', 'Patient')
+    headerLabelKey: 'patient',
+    headerLabelDefault: 'Patient',
+    key: 'patientName',
+  },
+  age: {
+    // t('age', 'Age')
+    headerLabelKey: 'age',
+    headerLabelDefault: 'Age',
+    key: 'patientAge',
+  },
+  sex: {
+    // t('sex', 'Sex')
+    headerLabelKey: 'sex',
+    headerLabelDefault: 'Sex',
+    key: 'patientSex',
+  },
+  totalOrders: {
+    // t('totalOrders', 'Total Orders')
+    headerLabelKey: 'totalOrders',
+    headerLabelDefault: 'Total Orders',
+    key: 'totalOrders',
+  },
+  action: {
+    // t('action', 'Action')
+    headerLabelKey: 'action',
+    headerLabelDefault: 'Action',
+    key: 'action',
+  },
+  patientId: {
+    // t('patientId', 'Patient ID')
+    headerLabelKey: 'patientId',
+    headerLabelDefault: 'Patient ID',
+    key: 'patientId',
+  },
+};
+
+export interface OrdersDataTableProps {
+  /* Whether the data table should include a status filter dropdown */
+  useFilter?: boolean;
+  actionsSlotName?: string;
+  excludeColumns?: Array<string>;
+  fulfillerStatus?: FulfillerStatus;
+  newOrdersOnly?: boolean;
+  excludeCanceledAndDiscontinuedOrders?: boolean;
+  actions?: Array<OrderAction>;
+}
 
 const OrdersDataTable: React.FC<OrdersDataTableProps> = (props) => {
   const { t } = useTranslation();
   const [filter, setFilter] = useState<FulfillerStatus>(null);
   const [searchString, setSearchString] = useState('');
+  const { labTableColumns, patientIdIdentifierTypeUuid } = useConfig<Config>();
 
-  const { labOrders, isLoading } = useLabOrders(
-    props.useFilter ? filter : props.fulfillerStatus,
-    props.excludeCanceledAndDiscontinuedOrders,
-  );
+  const { labOrders, isLoading } = useLabOrders({
+    status: props.useFilter ? filter : props.fulfillerStatus,
+    newOrdersOnly: props.newOrdersOnly,
+    excludeCanceled: props.excludeCanceledAndDiscontinuedOrders,
+    includePatientId: labTableColumns.includes('patientId'),
+  });
 
-  const flattenedLabOrders: Order[] = useMemo(() => {
+  const flattenedLabOrders: Array<FlattenedOrder> = useMemo(() => {
     return (
       labOrders?.map((order) => {
         return {
-          ...order,
+          id: order.uuid,
+          patientUuid: order.patient.uuid,
+          orderNumber: order.orderNumber,
           dateActivated: formatDate(parseDate(order.dateActivated)),
-          patientName: order.patient?.person.display,
-          patientUuid: order.patient?.uuid,
-          patientAge: order.patient?.person?.age,
-          status: order.fulfillerStatus ?? '--',
-          orderer: order.orderer,
+          fulfillerStatus: order.fulfillerStatus,
+          urgency: order.urgency,
+          orderer: order.orderer?.display,
+          instructions: order.instructions,
+          fulfillerComment: order.fulfillerComment,
+          display: order.display,
         };
       }) ?? []
     );
   }, [labOrders]);
 
-  function groupOrdersById(orders) {
-    if (orders && orders.length > 0) {
-      const groupedOrders = orders.reduce((acc, item) => {
-        if (!acc[item.patientUuid]) {
-          acc[item.patientUuid] = [];
-        }
-        acc[item.patientUuid].push(item);
-        return acc;
-      }, {});
+  const groupedOrdersByPatient = useMemo(() => {
+    if (labOrders && labOrders.length > 0) {
+      const patientUuids = [...new Set(labOrders.map((order) => order.patient.uuid))];
 
-      return Object.keys(groupedOrders).map((patientId) => ({
-        patientId: patientId,
-        orders: groupedOrders[patientId],
-      }));
+      return patientUuids.map((patientUuid) => {
+        const labOrdersForPatient = labOrders.filter((order) => order.patient.uuid === patientUuid);
+        const patient: Patient = labOrdersForPatient[0]?.patient;
+        const flattenedLabOrdersForPatient = flattenedLabOrders.filter((order) => order.patientUuid === patientUuid);
+        return {
+          patientId: patient.identifiers?.find(
+            (identifier) =>
+              identifier.preferred &&
+              !identifier.voided &&
+              identifier.identifierType.uuid === patientIdIdentifierTypeUuid,
+          )?.identifier,
+          patientUuid: patientUuid,
+          patientName: patient.person.display,
+          patientAge: patient.person.age,
+          patientSex: patient.person.gender,
+          totalOrders: flattenedLabOrdersForPatient.length,
+          orders: flattenedLabOrdersForPatient,
+          originalOrders: labOrdersForPatient,
+        };
+      });
     } else {
       return [];
     }
-  }
+  }, [flattenedLabOrders, labOrders, patientIdIdentifierTypeUuid]);
 
-  const groupedOrdersByPatient = groupOrdersById(flattenedLabOrders);
+  const searchResults = useMemo(() => {
+    if (searchString && searchString.trim() !== '') {
+      // Normalize the search string to lowercase
+      const lowerSearchString = searchString.toLowerCase();
+      return groupedOrdersByPatient.filter(
+        (orderGroup) =>
+          (labTableColumns.includes('name') && orderGroup.patientName.toLowerCase().includes(lowerSearchString)) ||
+          (labTableColumns.includes('patientId') && orderGroup.patientId.toLowerCase().includes(lowerSearchString)) ||
+          orderGroup.orders.some((order) => order.orderNumber.toLowerCase().includes(lowerSearchString)),
+      );
+    }
 
-  const searchResults = useSearchGroupedResults(groupedOrdersByPatient, searchString);
+    return groupedOrdersByPatient;
+  }, [searchString, groupedOrdersByPatient, labTableColumns]);
 
   const orderStatuses = [
     { value: null, display: t('all', 'All') },
-    { value: 'NEW', display: t('newStatus', 'NEW') },
     { value: 'RECEIVED', display: t('receivedStatus', 'RECEIVED') },
     { value: 'IN_PROGRESS', display: t('inProgressStatus', 'IN_PROGRESS') },
     { value: 'COMPLETED', display: t('completedStatus', 'COMPLETED') },
@@ -92,17 +177,23 @@ const OrdersDataTable: React.FC<OrdersDataTableProps> = (props) => {
   ];
 
   const columns = useMemo(() => {
-    const baseColumns = [
-      { id: 0, header: t('patient', 'Patient'), key: 'patientName' },
-      { id: 1, header: t('age', 'Age'), key: 'patientAge' },
-      { id: 2, header: t('gender', 'Gender'), key: 'patientGender' },
-      { id: 3, header: t('totalOrders', 'Total Orders'), key: 'totalOrders' },
-    ];
-
-    const showActionColumn = flattenedLabOrders.some((order) => order.fulfillerStatus === 'COMPLETED');
-
-    return showActionColumn ? [...baseColumns, { id: 4, header: t('action', 'Action'), key: 'action' }] : baseColumns;
-  }, [t, flattenedLabOrders]);
+    return labTableColumns
+      .map((column) => {
+        const spec = labTableColumnSpec[column];
+        if (!spec) {
+          throw new Error(`Lab table has been configured with an invalid column: ${column}`);
+        }
+        if (spec.key === 'action') {
+          const showActionColumn = flattenedLabOrders.some((order) => order.fulfillerStatus === 'COMPLETED');
+          if (!showActionColumn) {
+            return null;
+          }
+        }
+        return { header: t(spec.headerLabelKey, spec.headerLabelDefault), key: spec.key };
+      })
+      .filter(Boolean)
+      .map((column, index) => ({ ...column, id: index }));
+  }, [t, flattenedLabOrders, labTableColumns]);
 
   const pageSizes = [10, 20, 30, 40, 50];
   const [currentPageSize, setPageSize] = useState(10);
@@ -127,32 +218,28 @@ const OrdersDataTable: React.FC<OrdersDataTableProps> = (props) => {
   };
 
   const tableRows = useMemo(() => {
-    return paginatedLabOrders.map((order) => ({
-      id: order.patientId,
-      patientName: order.orders[0]?.patient.person.display,
-      orders: order.orders,
-      totalOrders: order.orders?.length,
-      patientAge: order.orders[0]?.patient?.person?.age,
-      patientGender: order.orders[0]?.patient?.person?.gender || '',
-      action: order.orders.some((o) => o.fulfillerStatus === 'COMPLETED') ? (
+    return paginatedLabOrders.map((groupedOrder) => ({
+      ...groupedOrder,
+      id: groupedOrder.patientUuid,
+      action: groupedOrder.orders.some((o) => o.fulfillerStatus === 'COMPLETED') ? (
         <div className={styles.actionCell}>
           <OverflowMenu aria-label="Actions" flipped iconDescription="Actions">
             <ExtensionSlot
               className={styles.transitionOverflowMenuItemSlot}
               name="transition-overflow-menu-item-slot"
-              state={{ patientUuid: order?.patientId }}
+              state={{ patientUuid: groupedOrder.patientUuid }}
               // Without tabIndex={0} here, the overflow menu incorrectly sets initial focus to the second item instead of the first.
               tabIndex={0}
             />
             <OverflowMenuItem
               className={styles.menuitem}
               itemText={t('editResults', 'Edit results')}
-              onClick={() => handleLaunchModal(order?.orders)}
+              onClick={() => handleLaunchModal(groupedOrder.originalOrders)}
             />
             <OverflowMenuItem
               className={styles.menuitem}
               itemText={t('printTestResults', 'Print test results')}
-              onClick={() => handlePrintModal(order?.orders)}
+              onClick={() => handlePrintModal(groupedOrder.originalOrders)}
             />
           </OverflowMenu>
         </div>
@@ -218,7 +305,7 @@ const OrdersDataTable: React.FC<OrdersDataTableProps> = (props) => {
                     <TableExpandedRow colSpan={headers.length + 2}>
                       <ListOrderDetails
                         actions={props.actions}
-                        groupedOrders={groupedOrdersByPatient.find((item) => item.patientId === row.id)}
+                        groupedOrders={groupedOrdersByPatient.find((item) => item.patientUuid === row.id)}
                       />
                     </TableExpandedRow>
                   ) : (

package/src/components/orders-table/orders-data-table.test.tsx

@@ -0,0 +1,215 @@
+import React from 'react';
+import { render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import OrdersDataTable from './orders-data-table.component';
+import { useConfig, getDefaultsFromConfigSchema, type Patient, Person } from '@openmrs/esm-framework';
+import { configSchema, type Config } from '../../config-schema';
+import { useLabOrders, type UseLabOrdersParams } from '../../laboratory-resource';
+import { type Order } from '@openmrs/esm-patient-common-lib';
+
+jest.mock('../../laboratory-resource', () => ({
+  useLabOrders: jest.fn(),
+}));
+
+const mockUseConfig = jest.mocked(useConfig<Config>);
+const mockUseLabOrders = jest.mocked(useLabOrders);
+
+function mockUseLabOrdersImplementation(props: Partial<UseLabOrdersParams>) {
+  const mockPatient1: Partial<Patient> = {
+    uuid: 'patient-uuid-1',
+    display: 'PAT-001 - Pete Seeger',
+    identifiers: props.includePatientId
+      ? [
+          {
+            uuid: 'identifier-uuid-1',
+            identifier: 'PAT-001',
+            preferred: true,
+            voided: false,
+            identifierType: {
+              uuid: 'identifier-type-uuid-1',
+            },
+          },
+          {
+            uuid: 'identifier-uuid-2',
+            identifier: 'BAD-ID-NOT-PREFERRED',
+            preferred: false,
+            voided: false,
+            identifierType: {
+              uuid: 'identifier-type-uuid-1',
+            },
+          },
+        ]
+      : undefined,
+    person: {
+      uuid: 'person-uuid-1',
+      display: 'Pete Seeger',
+      age: 70,
+      gender: 'M',
+    },
+  };
+  const mockPatient2: Partial<Patient> = {
+    uuid: 'patient-uuid-2',
+    display: 'PAT-002 - Bob Dylan',
+    identifiers: props.includePatientId
+      ? [
+          {
+            uuid: 'identifier-uuid-3',
+            identifier: 'BAD-ID-WRONG-TYPE',
+            preferred: true,
+            voided: false,
+            identifierType: {
+              uuid: '05a29f94-c0ed-11e2-94be-8c13b969e334',
+            },
+          },
+          {
+            uuid: 'identifier-uuid-4',
+            identifier: 'PAT-002',
+            preferred: true,
+            voided: false,
+            identifierType: {
+              uuid: 'identifier-type-uuid-1',
+            },
+          },
+        ]
+      : undefined,
+    person: {
+      uuid: 'person-uuid-2',
+      display: 'Bob Dylan',
+      age: 60,
+      gender: 'M',
+    },
+  };
+
+  const mockOrderer = {
+    uuid: 'orderer-uuid-1',
+    display: 'Dr. John Doe',
+    person: {
+      display: 'Dr. John Doe',
+    },
+  };
+
+  const labOrders = [
+    {
+      uuid: 'order-uuid-1',
+      orderNumber: 'ORD-001',
+      patient: mockPatient1 as Patient,
+      dateActivated: '2021-01-01',
+      fulfillerStatus: 'RECEIVED',
+      urgency: 'ROUTINE',
+      orderer: mockOrderer,
+      instructions: 'Inspect banjo & check tuning',
+      fulfillerComment: null,
+      display: 'Banjo Inspection',
+    },
+    {
+      uuid: 'order-uuid-2',
+      orderNumber: 'ORD-002',
+      patient: mockPatient1 as Patient,
+      dateActivated: '2021-01-01',
+      fulfillerStatus: 'RECEIVED',
+      urgency: 'ROUTINE',
+      orderer: mockOrderer,
+      instructions: 'Give it a strum',
+      fulfillerComment: null,
+      display: 'Guitar Inspection',
+    },
+    {
+      uuid: 'order-uuid-3',
+      orderNumber: 'ORD-003',
+      patient: mockPatient2 as Patient,
+      dateActivated: '2021-01-01',
+      fulfillerStatus: 'RECEIVED',
+      urgency: 'EMERGENCY',
+      orderer: mockOrderer,
+      instructions: 'Make some noise',
+      fulfillerComment: null,
+      display: 'Sound Check',
+    },
+  ]
+    .filter((order) => !props.status || order.fulfillerStatus === props.status)
+    .filter((order) => !props.excludeCanceled || order.fulfillerStatus !== 'CANCELLED') as Array<Order>;
+  return {
+    labOrders,
+    isLoading: false,
+    isError: false,
+    mutate: jest.fn(),
+    isValidating: false,
+  };
+}
+
+describe('OrdersDataTable', () => {
+  beforeEach(() => {
+    mockUseLabOrders.mockImplementation(mockUseLabOrdersImplementation);
+  });
+
+  it('should render one row per patient and show lab details', async () => {
+    mockUseConfig.mockReturnValue({
+      ...getDefaultsFromConfigSchema(configSchema),
+    });
+
+    render(<OrdersDataTable />);
+    const table = screen.getByRole('table');
+    expect(table).toBeInTheDocument();
+    const rows = screen.getAllByRole('row');
+    expect(rows).toHaveLength(5);
+    const dataRows = rows.slice(1).filter((row) => !row.classList.contains('hiddenRow'));
+    expect(dataRows).toHaveLength(2);
+    const headerRow = rows[0];
+    expect(headerRow).toHaveTextContent('Patient');
+    expect(headerRow).toHaveTextContent('Age');
+    expect(headerRow).toHaveTextContent('Sex');
+    expect(headerRow).toHaveTextContent('Total Orders');
+    const row1 = dataRows[0];
+    expect(row1).toHaveTextContent('Pete Seeger');
+    expect(row1).toHaveTextContent('70');
+    expect(row1).toHaveTextContent('M');
+    expect(row1).toHaveTextContent('2');
+    const row2 = dataRows[1];
+    expect(row2).toHaveTextContent('Bob Dylan');
+    expect(row2).toHaveTextContent('60');
+    expect(row2).toHaveTextContent('M');
+    expect(row2).toHaveTextContent('1');
+
+    const user = userEvent.setup();
+    await user.click(within(row1).getByLabelText('Expand current row'));
+
+    const orderDetailsTables = within(table).getAllByRole('table');
+    expect(orderDetailsTables).toHaveLength(2);
+    const orderDetailsTable1 = orderDetailsTables[0];
+    const orderDetailsTable2 = orderDetailsTables[1];
+    expect(orderDetailsTable1).toHaveTextContent('Banjo Inspection');
+    expect(orderDetailsTable1).toHaveTextContent('Inspect banjo & check tuning');
+    expect(orderDetailsTable1).toHaveTextContent('Dr. John Doe');
+    expect(orderDetailsTable1).toHaveTextContent('01-Jan-2021');
+    expect(orderDetailsTable1).toHaveTextContent('Received');
+    expect(orderDetailsTable1).toHaveTextContent('Routine');
+    expect(orderDetailsTable2).toHaveTextContent('Guitar Inspection');
+    expect(orderDetailsTable2).toHaveTextContent('Give it a strum');
+    expect(orderDetailsTable2).toHaveTextContent('Dr. John Doe');
+    expect(orderDetailsTable2).toHaveTextContent('01-Jan-2021');
+    expect(orderDetailsTable2).toHaveTextContent('Received');
+    expect(orderDetailsTable2).toHaveTextContent('Routine');
+  });
+
+  it('should show patient identifier if it is configured', () => {
+    mockUseConfig.mockReturnValue({
+      ...getDefaultsFromConfigSchema(configSchema),
+      labTableColumns: ['patientId', 'age', 'totalOrders'],
+      patientIdIdentifierTypeUuid: 'identifier-type-uuid-1',
+    });
+    render(<OrdersDataTable />);
+    const rows = screen.getAllByRole('row');
+    expect(rows).toHaveLength(5);
+    const dataRows = rows.slice(1).filter((row) => !row.classList.contains('hiddenRow'));
+    expect(dataRows).toHaveLength(2);
+    const row1 = dataRows[0];
+    expect(row1).toHaveTextContent('PAT-001');
+    expect(row1).toHaveTextContent('70');
+    expect(row1).toHaveTextContent('2');
+    const row2 = dataRows[1];
+    expect(row2).toHaveTextContent('PAT-002');
+    expect(row2).toHaveTextContent('60');
+    expect(row2).toHaveTextContent('1');
+    expect(screen.queryByText(/BAD-ID/)).not.toBeInTheDocument();
+  });
+});

package/src/config-schema.ts

@@ -1,4 +1,7 @@
-import { Type } from '@openmrs/esm-framework';
+import { Type, validators } from '@openmrs/esm-framework';
+
+const allowedLabTableColumns = ['name', 'age', 'sex', 'totalOrders', 'action', 'patientId'] as const;
+type LabTableColumnName = (typeof allowedLabTableColumns)[number];
 
 export const configSchema = {
   laboratoryOrderTypeUuid: {
@@ -24,6 +27,20 @@ export const configSchema = {
     },
     _description: 'The patient chart dashboard to navigate to from the lab app.',
   },
+  labTableColumns: {
+    _type: Type.Array,
+    _default: ['name', 'age', 'sex', 'totalOrders', 'action'] as Array<LabTableColumnName>,
+    _description: 'The columns to display in the lab table. Allowed values: ' + allowedLabTableColumns.join(', '),
+    _elements: {
+      _type: Type.String,
+      _validators: [validators.oneOf(allowedLabTableColumns)],
+    },
+  },
+  patientIdIdentifierTypeUuid: {
+    _type: Type.UUID,
+    _default: '05a29f94-c0ed-11e2-94be-8c13b969e334',
+    _description: 'Needed if the "id" column of "labTableColumns" is used. Is the OpenMRS ID by default.',
+  },
 };
 
 export type Config = {
@@ -33,4 +50,6 @@ export type Config = {
     redirectToResultsViewer: string;
     redirectToOrders: string;
   };
+  labTableColumns: Array<LabTableColumnName>;
+  patientIdIdentifierTypeUuid: string;
 };

package/src/lab-tabs/data-table-extensions/tests-ordered-table.extension.tsx

@@ -6,7 +6,7 @@ const TestsOrderedTable: React.FC = () => {
     <OrdersDataTable
       excludeColumns={[]}
       actionsSlotName="tests-ordered-actions-slot"
-      fulfillerStatus="NEW"
+      newOrdersOnly={true}
       actions={[
         { actionName: 'pickupLabRequest', order: 0 },
         { actionName: 'rejectLabRequest', order: 1 },

package/src/lab-tiles/all-lab-requests-tile.component.tsx

@@ -6,7 +6,7 @@ import LabSummaryTile from '../components/summary-tile/lab-summary-tile.componen
 const AllLabRequestsTile = () => {
   const { t } = useTranslation();
 
-  const { labOrders } = useLabOrders('NEW');
+  const { labOrders } = useLabOrders({ newOrdersOnly: true });
 
   return (
     <LabSummaryTile

package/src/lab-tiles/completed-lab-requests-tile.component.tsx

@@ -5,7 +5,7 @@ import LabSummaryTile from '../components/summary-tile/lab-summary-tile.componen
 
 const CompletedLabRequestsTile = () => {
   const { t } = useTranslation();
-  const { labOrders } = useLabOrders('COMPLETED', false);
+  const { labOrders } = useLabOrders({ status: 'COMPLETED', excludeCanceled: false });
 
   return (
     <LabSummaryTile

package/src/lab-tiles/in-progress-lab-requests-tile.component.tsx

@@ -5,7 +5,7 @@ import LabSummaryTile from '../components/summary-tile/lab-summary-tile.componen
 
 const InProgressLabRequestsTile = () => {
   const { t } = useTranslation();
-  const { labOrders } = useLabOrders('IN_PROGRESS');
+  const { labOrders } = useLabOrders({ status: 'IN_PROGRESS' });
 
   return (
     <LabSummaryTile

package/src/laboratory-resource.ts

@@ -1,9 +1,22 @@
-import { useMemo } from 'react';
 import dayjs from 'dayjs';
 import useSWR from 'swr';
 import { openmrsFetch, restBaseUrl, useAppContext, useConfig } from '@openmrs/esm-framework';
-import { type Order } from '@openmrs/esm-patient-common-lib';
-import type { DateFilterContext, FulfillerStatus, GroupedOrders } from './types';
+import { type Order, type FulfillerStatus } from '@openmrs/esm-patient-common-lib';
+import type { DateFilterContext } from './types';
+
+const useLabOrdersDefaultParams: UseLabOrdersParams = {
+  status: null,
+  newOrdersOnly: false,
+  excludeCanceled: true,
+  includePatientId: false,
+}
+
+export interface UseLabOrdersParams {
+  status: FulfillerStatus;
+  newOrdersOnly: boolean;
+  excludeCanceled: boolean;
+  includePatientId: boolean;
+}
 
 /**
  * Custom hook for retrieving laboratory orders based on the specified status.
@@ -11,18 +24,18 @@ import type { DateFilterContext, FulfillerStatus, GroupedOrders } from './types'
  * @param status - The status of the orders to retrieve
  * @param excludeCanceled - Whether to exclude canceled, discontinued and expired orders
  */
-export function useLabOrders(status: 'NEW' | FulfillerStatus = null, excludeCanceled = true) {
+export function useLabOrders(params: Partial<UseLabOrdersParams> = useLabOrdersDefaultParams) {
+  const { status, newOrdersOnly, excludeCanceled, includePatientId } = { ...useLabOrdersDefaultParams, ...params };
   const { dateRange } = useAppContext<DateFilterContext>('laboratory-date-filter') ?? {
     dateRange: [dayjs().startOf('day').toDate(), new Date()],
   };
 
   const { laboratoryOrderTypeUuid } = useConfig();
-  const fulfillerStatus = useMemo(() => (status === 'NEW' ? null : status), [status]);
-  const newOrdersOnly = status === 'NEW';
-  const customRepresentation =
-    'custom:(uuid,orderNumber,patient:(uuid,display,person:(uuid,display,age,gender)),concept:(uuid,display),action,careSetting:(uuid,display,description,careSettingType,display),previousOrder,dateActivated,scheduledDate,dateStopped,autoExpireDate,encounter:(uuid,display),orderer:(uuid,display),orderReason,orderReasonNonCoded,orderType:(uuid,display,name,description,conceptClasses,parent),urgency,instructions,commentToFulfiller,display,fulfillerStatus,fulfillerComment,specimenSource,laterality,clinicalHistory,frequency,numberOfRepeats)';
+  const customRepresentation = `custom:(uuid,orderNumber,patient:(uuid,display,person:(uuid,display,age,gender)${
+    includePatientId ? ',identifiers' : ''
+  }),concept:(uuid,display),action,careSetting:(uuid,display,description,careSettingType,display),previousOrder,dateActivated,scheduledDate,dateStopped,autoExpireDate,encounter:(uuid,display),orderer:(uuid,display),orderReason,orderReasonNonCoded,orderType:(uuid,display,name,description,conceptClasses,parent),urgency,instructions,commentToFulfiller,display,fulfillerStatus,fulfillerComment,specimenSource,laterality,clinicalHistory,frequency,numberOfRepeats)`;
   let url = `${restBaseUrl}/order?orderTypes=${laboratoryOrderTypeUuid}&v=${customRepresentation}`;
-  url = fulfillerStatus ? url + `&fulfillerStatus=${fulfillerStatus}` : url;
+  url = status ? url + `&fulfillerStatus=${status}` : url;
   url = excludeCanceled ? `${url}&excludeCanceledAndExpired=true&excludeDiscontinueOrders=true` : url;
   // The usage of SWR's mutator seems to only suffice for cases where we don't apply a status filter
   url = dateRange
@@ -36,11 +49,9 @@ export function useLabOrders(status: 'NEW' | FulfillerStatus = null, excludeCanc
   }>(`${url}`, openmrsFetch);
 
   const filteredOrders =
-    data?.data &&
-    newOrdersOnly &&
-    data.data.results.filter((order) => order?.action === 'NEW' && order?.fulfillerStatus === null);
+    data?.data?.results?.filter((order) => !newOrdersOnly || (order?.action === 'NEW' && order?.fulfillerStatus === null));
   return {
-    labOrders: filteredOrders || data?.data.results || [],
+    labOrders: filteredOrders ?? [],
     isLoading,
     isError: error,
     mutate,
@@ -48,26 +59,6 @@ export function useLabOrders(status: 'NEW' | FulfillerStatus = null, excludeCanc
   };
 }
 
-export function useSearchGroupedResults(data: Array<GroupedOrders>, searchString: string) {
-  const searchResults = useMemo(() => {
-    if (searchString && searchString.trim() !== '') {
-      // Normalize the search string to lowercase
-      const lowerSearchString = searchString.toLowerCase();
-      return data.filter((orderGroup) =>
-        orderGroup.orders.some(
-          (order) =>
-            order.orderNumber.toLowerCase().includes(lowerSearchString) ||
-            order.patient.display.toLowerCase().includes(lowerSearchString),
-        ),
-      );
-    }
-
-    return data;
-  }, [searchString, data]);
-
-  return searchResults;
-}
-
 export function setFulfillerStatus(orderId: string, status: FulfillerStatus, abortController: AbortController) {
   return openmrsFetch(`${restBaseUrl}/order/${orderId}/fulfillerdetails/`, {
     method: 'POST',