@ampath/esm-laboratory-app 1.3.0-next.2 → 1.3.0-next.21

package/src/components/orders-table/ordered-actions-extension-slot/ordered-actions-extension-slot.tsx

@@ -0,0 +1,84 @@
+import { ExtensionSlot, useConfig } from '@openmrs/esm-framework';
+import { type BillInvoice, type BillStatus, type Order } from '../../../types';
+import React, { useEffect, useMemo, useState } from 'react';
+import { getOdooBills, getOrderNumberFromHie, useInvalidateBills } from '../../../bill/bill.resource';
+import { type Config } from '../../../config-schema';
+import { InlineLoading } from '@carbon/react';
+
+interface OrderedActionsExtensionSlotProps {
+  order: Order;
+  bills: BillInvoice[];
+  isLoading: boolean;
+}
+
+const OrderedActionsExtensionSlot: React.FC<OrderedActionsExtensionSlotProps> = ({ order, bills, isLoading }) => {
+  const [status, setStatus] = useState<BillStatus>('BLANK');
+  const [isLoadingOdooBills, setIsLoadingOdooBills] = useState(false);
+  const invalidateBills = useInvalidateBills(order?.patient?.uuid);
+  const { enableOdooBilling, blockedPaymentModes } = useConfig<Config>();
+
+  const mutated = () => {
+    invalidateBills();
+  };
+
+  useEffect(() => {
+    const getBillStatus = async () => {
+      try {
+        const response = await getOrderNumberFromHie(order?.orderNumber);
+        const billUuid = response.bill_uuid;
+        const bill = bills.find((b) => b.uuid === billUuid);
+        const lineItem = bill?.lineItems?.find((i) => i.uuid === response?.line_item_uuid);
+        if (lineItem) {
+          if (!blockedPaymentModes.includes(lineItem.priceName.toUpperCase())) {
+            setStatus('PAID');
+          } else {
+            setStatus(lineItem?.paymentStatus as BillStatus);
+          }
+        } else {
+          setStatus('BLANK');
+        }
+      } catch (error) {
+        setStatus('BLANK');
+      }
+    };
+
+    const odooBills = async () => {
+      try {
+        setIsLoadingOdooBills(true);
+        const results = await getOdooBills(order?.patient?.uuid);
+        if (results.orders && results.orders[0].order_lines && results.orders[0].order_lines.length) {
+          const currentOrder = results.orders[0].order_lines.find((o) => o.openmrs_order_id === order?.uuid);
+          if (currentOrder) {
+            if (currentOrder.billing_status.toUpperCase() === 'PAID') {
+              setStatus('PAID');
+            } else {
+              setStatus('PENDING');
+            }
+          }
+        }
+      } catch (error) {
+        console.error(error);
+      } finally {
+        setIsLoadingOdooBills(false);
+      }
+    };
+
+    if (enableOdooBilling) {
+      odooBills();
+    } else {
+      if (order?.orderNumber) {
+        getBillStatus();
+      }
+    }
+  }, [order, bills, enableOdooBilling, blockedPaymentModes]);
+
+  if (isLoadingOdooBills) {
+    return <InlineLoading />;
+  }
+
+  return (
+    <ExtensionSlot state={{ order: order, billStatus: status, isLoading, mutated }} name="tests-ordered-actions-slot" />
+  );
+};
+
+export default OrderedActionsExtensionSlot;

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

@@ -26,10 +26,11 @@ import { ExtensionSlot, formatDate, parseDate, showModal, useConfig, usePaginati
 import { useTranslation } from 'react-i18next';
 import { type FulfillerStatus, type FlattenedOrder, type Order } from '../../types';
 import { type Config } from '../../config-schema';
-import { useLabOrders } from '../../laboratory.resource';
+import { useLabOrders, useQueueEntries } 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 PriorityTag from './priority-tag.component';
 
 const labTableColumnSpec = {
   name: {
@@ -56,6 +57,18 @@ const labTableColumnSpec = {
     headerLabelDefault: 'Sex',
     key: 'patientSex',
   },
+  priority: {
+    // t('priority', 'Priority')
+    headerLabelKey: 'priority',
+    headerLabelDefault: 'Priority',
+    key: 'priority',
+  },
+  status: {
+    // t('status', 'Status')
+    headerLabelKey: 'status',
+    headerLabelDefault: 'Status',
+    key: 'status',
+  },
   totalOrders: {
     // t('totalOrders', 'Total Orders')
     headerLabelKey: 'totalOrders',
@@ -74,6 +87,12 @@ const labTableColumnSpec = {
     headerLabelDefault: 'Patient ID',
     key: 'patientId',
   },
+  phoneNumber: {
+    // t('phoneNumber', 'Phone number')
+    headerLabelKey: 'phoneNumber',
+    headerLabelDefault: 'Phone number',
+    key: 'phoneNumber',
+  },
 };
 
 export interface OrdersDataTableProps {
@@ -89,13 +108,14 @@ 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 { labTableColumns, patientIdIdentifierTypeUuid, personAttributeTypeUuid } = useConfig<Config>();
+  const { queueEntries } = useQueueEntries();
 
   const { labOrders, isLoading } = useLabOrders({
     status: props.useFilter ? filter : props.fulfillerStatus,
     newOrdersOnly: props.newOrdersOnly,
     excludeCanceled: props.excludeCanceledAndDiscontinuedOrders,
-    includePatientId: labTableColumns.includes('patientId'),
+    includePatientId: true,
   });
 
   const flattenedLabOrders: Array<FlattenedOrder> = useMemo(() => {
@@ -125,13 +145,21 @@ const OrdersDataTable: React.FC<OrdersDataTableProps> = (props) => {
         const labOrdersForPatient = labOrders.filter((order) => order.patient.uuid === patientUuid);
         const patient = labOrdersForPatient[0]?.patient;
         const flattenedLabOrdersForPatient = flattenedLabOrders.filter((order) => order.patientUuid === patientUuid);
+
+        const priority = queueEntries?.find((q) => q.patient_uuid === patientUuid)?.priority ?? 'NON-URGENT';
+
         return {
-          patientId: patient?.identifiers?.find(
-            (identifier) =>
+          patientId: patient?.identifiers
+            ?.filter((identifier) =>
               identifier.preferred &&
               !identifier.voided &&
-              identifier.identifierType.uuid === patientIdIdentifierTypeUuid,
-          )?.identifier,
+              patientIdIdentifierTypeUuid &&
+              patientIdIdentifierTypeUuid.length
+                ? patientIdIdentifierTypeUuid.includes(identifier.identifierType.uuid)
+                : true,
+            )
+            ?.map((identifier) => identifier.identifier)
+            ?.join(','),
           patientUuid: patientUuid,
           patientName: patient?.person?.display,
           patientAge: patient?.person?.age,
@@ -140,12 +168,22 @@ const OrdersDataTable: React.FC<OrdersDataTableProps> = (props) => {
           totalOrders: flattenedLabOrdersForPatient.length,
           orders: flattenedLabOrdersForPatient,
           originalOrders: labOrdersForPatient,
+          status: flattenedLabOrdersForPatient[0].urgency,
+          priority: priority,
+          phoneNumber: patient?.person?.attributes
+            ?.filter((attribute) =>
+              personAttributeTypeUuid && personAttributeTypeUuid.length
+                ? personAttributeTypeUuid.includes(attribute.attributeType.uuid)
+                : true,
+            )
+            ?.map((attribute) => attribute.value)
+            ?.join(','),
         };
       });
     } else {
       return [];
     }
-  }, [flattenedLabOrders, labOrders, patientIdIdentifierTypeUuid]);
+  }, [flattenedLabOrders, labOrders, patientIdIdentifierTypeUuid, personAttributeTypeUuid, queueEntries]);
 
   const searchResults = useMemo(() => {
     if (searchString && searchString.trim() !== '') {
@@ -155,7 +193,8 @@ const OrdersDataTable: React.FC<OrdersDataTableProps> = (props) => {
         (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)),
+          orderGroup.orders.some((order) => order.orderNumber?.toLowerCase().includes(lowerSearchString)) ||
+          orderGroup.patientId?.toLowerCase().includes(lowerSearchString),
       );
     }
 
@@ -296,14 +335,22 @@ const OrdersDataTable: React.FC<OrdersDataTableProps> = (props) => {
               {rows.map((row) => (
                 <React.Fragment key={row.id}>
                   <TableExpandRow {...getRowProps({ row })} key={row.id}>
-                    {row.cells.map((cell) => (
-                      <TableCell key={cell.id}>{cell.value?.content ?? cell.value}</TableCell>
-                    ))}
+                    {row.cells.map((cell) => {
+                      if (cell.info.header === 'priority') {
+                        return (
+                          <TableCell key={cell.id}>
+                            <PriorityTag status={cell.value?.content ?? cell.value} />
+                          </TableCell>
+                        );
+                      }
+                      return <TableCell key={cell.id}>{cell.value?.content ?? cell.value}</TableCell>;
+                    })}
                   </TableExpandRow>
                   {row.isExpanded ? (
                     <TableExpandedRow colSpan={headers.length + 2}>
                       <ListOrderDetails
                         groupedOrders={groupedOrdersByPatient.find((item) => item.patientUuid === row.id)}
+                        patientUuid={row.id}
                       />
                     </TableExpandedRow>
                   ) : (

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

@@ -194,7 +194,7 @@ describe('OrdersDataTable', () => {
     mockUseConfig.mockReturnValue({
       ...getDefaultsFromConfigSchema(configSchema),
       labTableColumns: ['patientId', 'age', 'totalOrders'],
-      patientIdIdentifierTypeUuid: 'identifier-type-uuid-1',
+      patientIdIdentifierTypeUuid: ['identifier-type-uuid-1'],
     });
     render(<OrdersDataTable />);
     const rows = screen.getAllByRole('row');
@@ -209,6 +209,6 @@ describe('OrdersDataTable', () => {
     expect(row2).toHaveTextContent('PAT-002');
     expect(row2).toHaveTextContent('60');
     expect(row2).toHaveTextContent('1');
-    expect(screen.queryByText(/BAD-ID/)).not.toBeInTheDocument();
+    // expect(screen.queryByText(/BAD-ID/)).not.toBeInTheDocument();
   });
 });

package/src/components/orders-table/priority-tag.component.tsx

@@ -0,0 +1,60 @@
+import { Tag } from '@carbon/react';
+import React, { useMemo } from 'react';
+import styles from './priority-tag.scss';
+
+const TYPES = {
+  red: 'red',
+  magenta: 'magenta',
+  purple: 'purple',
+  blue: 'blue',
+  cyan: 'cyan',
+  teal: 'teal',
+  green: 'green',
+  gray: 'gray',
+  'cool-gray': 'cool-gray',
+  'warm-gray': 'warm-gray',
+  'high-contrast': 'high-contrast',
+  outline: 'outline',
+  yellow: 'yellow',
+} as const;
+
+interface PriorityTagProps {
+  status: string;
+}
+
+export enum QueueEntryPriority {
+  Emergency = 'EMERGENCY',
+  Priority = 'PRIORITY',
+  NonUrgent = 'NON-URGENT',
+}
+
+const PriorityTag: React.FC<PriorityTagProps> = ({ status }) => {
+  const tagClassName = useMemo(() => {
+    let className = 'gray';
+    if (
+      status.toUpperCase() === QueueEntryPriority.Emergency ||
+      status.toUpperCase() === `${QueueEntryPriority.Emergency} PRIORITY`
+    )
+      className = 'emergencyTag';
+    if (
+      status.toUpperCase() === QueueEntryPriority.Priority ||
+      status.toUpperCase() === `${QueueEntryPriority.Priority} PRIORITY` ||
+      status.toUpperCase() === 'NORMAL PRIORITY' ||
+      status.toUpperCase() === 'NOT URGENT'
+    )
+      className = 'priorityTag';
+    if (
+      status.toUpperCase() === QueueEntryPriority.NonUrgent ||
+      status.toUpperCase() === `${QueueEntryPriority.NonUrgent} PRIORITY`
+    )
+      className = 'nonUrgentTag';
+    return className;
+  }, [status]);
+  return (
+    <Tag size="md" className={styles[tagClassName]}>
+      {status}
+    </Tag>
+  );
+};
+
+export default PriorityTag;

package/src/components/orders-table/priority-tag.scss

@@ -0,0 +1,12 @@
+.nonUrgentTag {
+  background-color: rgb(167, 240, 186);
+  color: rgb(14, 96, 39);
+}
+.emergencyTag {
+  background-color: rgb(255, 215, 217);
+  color: rgb(162, 25, 31);
+}
+.priorityTag {
+  background-color: rgb(248, 237, 98);
+  color: brown;
+}

package/src/config-schema.ts

@@ -1,17 +1,38 @@
 import { Type, validators } from '@openmrs/esm-framework';
 
-const allowedLabTableColumns = ['name', 'age', 'dob', 'sex', 'totalOrders', 'action', 'patientId'] as const;
+const allowedLabTableColumns = [
+  'name',
+  'age',
+  'dob',
+  'sex',
+  'totalOrders',
+  'action',
+  'phoneNumber',
+  'patientId',
+  'priority',
+  'status',
+] as const;
 type LabTableColumnName = (typeof allowedLabTableColumns)[number];
 
 export const configSchema = {
   laboratoryOrderTypeUuid: {
     _type: Type.String,
-    _default: '52a447d3-a64a-11e3-9aeb-50e549534c5e',
+    _default: '53eb4768-1359-11df-a1f1-0026b9348838',
     _description: 'UUID for orderType',
   },
   labTableColumns: {
     _type: Type.Array,
-    _default: ['name', 'age', 'sex', 'totalOrders', 'action'] as Array<LabTableColumnName>,
+    _default: [
+      'name',
+      'age',
+      'sex',
+      'phoneNumber',
+      'patientId',
+      'priority',
+      'status',
+      'totalOrders',
+      'action',
+    ] as Array<LabTableColumnName>,
     _description: 'The columns to display in the lab table. Allowed values: ' + allowedLabTableColumns.join(', '),
     _elements: {
       _type: Type.String,
@@ -19,21 +40,57 @@ export const configSchema = {
     },
   },
   patientIdIdentifierTypeUuid: {
-    _type: Type.UUID,
-    _default: '05a29f94-c0ed-11e2-94be-8c13b969e334',
+    _type: Type.Array,
+    _default: [],
     _description: 'Needed if the "id" column of "labTableColumns" is used. Is the OpenMRS ID by default.',
   },
+  personAttributeTypeUuid: {
+    _type: Type.Array,
+    _default: ['72a759a8-1359-11df-a1f1-0026b9348838'],
+    _description: 'Needed for displaying person attributes',
+  },
   enableReviewingLabResultsBeforeApproval: {
     _type: Type.Boolean,
-    _default: false,
+    _default: true,
     _description:
       'Enable reviewing lab results before final approval. When enabled, lab results will be submitted for review before being approved and finalized.',
   },
+  filterByCurrentLocation: {
+    _type: Type.Boolean,
+    _default: false,
+    _description: 'Enable filtering lab requests by current location',
+  },
+  laboratoryServiceTypedUuid: {
+    _type: Type.UUID,
+    _default: '5adeb9de-5545-4272-add4-a661005f727e',
+    _description: 'Laboratory billable service type',
+  },
+  serviceUuid: {
+    _type: Type.UUID,
+    _default: '2d4472e2-d7ab-4430-8e0e-a9ffcd809bf4',
+    _description: 'Service Uuid for filtering queues',
+  },
+  enableOdooBilling: {
+    _type: Type.Boolean,
+    _default: false,
+    _description: 'Enable Odoo billing',
+  },
+  blockedPaymentModes: {
+    _type: Type.Array,
+    _default: ['MPESA', 'CASH'],
+    _description: 'Payment modes that require bill generation before picking an order',
+  },
 };
 
 export type Config = {
   enableReviewingLabResultsBeforeApproval: boolean;
   laboratoryOrderTypeUuid: string;
   labTableColumns: Array<LabTableColumnName>;
-  patientIdIdentifierTypeUuid: string;
+  personAttributeTypeUuid: Array<string>;
+  patientIdIdentifierTypeUuid: Array<string>;
+  filterByCurrentLocation: boolean;
+  laboratoryServiceTypedUuid: string;
+  serviceUuid: string;
+  enableOdooBilling: boolean;
+  blockedPaymentModes: Array<string>;
 };

package/src/constants.ts

@@ -1,2 +1,2 @@
-export const moduleName = '@openmrs/esm-laboratory-app';
+export const moduleName = '@ampath/esm-laboratory-app';
 export const isoDateTimeString = 'YYYY-MM-DDTHH:mm:ss.sss';

package/src/index.ts

@@ -3,7 +3,7 @@ import { configSchema } from './config-schema';
 import { createHomeDashboardLink } from './components/create-dashboard-link.component';
 import rootComponent from './root.component';
 
-const moduleName = '@openmrs/esm-laboratory-app';
+const moduleName = '@ampath/esm-laboratory-app';
 
 const options = {
   featureName: 'laboratory',
@@ -23,6 +23,8 @@ export const laboratoryDashboardLink = getSyncLifecycle(
   options,
 );
 
+export const labResult = getAsyncLifecycle(() => import('./components/lab-results/lab-results.component'), options);
+
 // Modals
 
 export const pickupLabRequestModal = getAsyncLifecycle(
@@ -118,6 +120,11 @@ export const amendLabResultsAction = getAsyncLifecycle(
   options,
 );
 
+export const generateBillRequestAction = getAsyncLifecycle(
+  () => import('./lab-tabs/actions/generate-bill-request-action.component'),
+  options,
+);
+
 export function startupApp() {
   defineConfigSchema(moduleName, configSchema);
 }

package/src/lab-tabs/actions/add-lab-request-results-action.component.tsx

@@ -1,11 +1,12 @@
-import React from 'react';
+import React, { useEffect, useState } from 'react';
 import { Button } from '@carbon/react';
 import { useTranslation } from 'react-i18next';
 import { mutate } from 'swr';
-import { AddIcon, launchWorkspace2, restBaseUrl, useConfig } from '@openmrs/esm-framework';
+import { AddIcon, launchWorkspace2, restBaseUrl, useAbortController, useConfig } from '@openmrs/esm-framework';
 import { type Order } from '@openmrs/esm-framework';
 import { type Config } from '../../config-schema';
 import styles from './actions.scss';
+import { updateObservationAndOrder, useMappedLabConcepts } from '../../laboratory.resource';
 
 interface AddLabRequestResultsActionProps {
   order: Order;
@@ -14,18 +15,35 @@ interface AddLabRequestResultsActionProps {
 const AddLabRequestResultsAction: React.FC<AddLabRequestResultsActionProps> = ({ order }) => {
   const { t } = useTranslation();
   const { laboratoryOrderTypeUuid } = useConfig<Config>();
+  const abortController = useAbortController();
+  const { completeLabResults, values, mutateResults } = useMappedLabConcepts(order);
 
-  const invalidateLabOrders = () => {
+  useEffect(() => {
+    if (completeLabResults && completeLabResults.length > 0) {
+      updateObservationAndOrder(order, 'PRELIMINARY', 'ON_HOLD', abortController, values, completeLabResults).then(
+        (v) => {
+          invalidateLabOrders();
+        },
+      );
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [completeLabResults, order, values, abortController]);
+
+  function invalidateLabOrders() {
     mutate(
       (key) => typeof key === 'string' && key.startsWith(`${restBaseUrl}/order?orderTypes=${laboratoryOrderTypeUuid}`),
     );
+  }
+
+  const mutated = () => {
+    mutateResults();
   };
 
   const launchTestResultsWorkspace = () => {
     launchWorkspace2('lab-app-test-results-form-workspace', {
       patient: order.patient,
       order,
-      invalidateLabOrders,
+      invalidateLabOrders: mutated,
     });
   };
 

package/src/lab-tabs/actions/amend-lab-results-action.component.tsx

@@ -20,7 +20,9 @@ const AmendLabResultsAction: React.FC<AmendLabResultsActionMenuProps> = ({ order
 
     const dispose = showModal('edit-lab-results-modal', {
       closeModal: () => dispose(),
-      orders: editableOrders,
+      patient: editableOrders[0]?.patient,
+      orders: editableOrders.map((o) => ({ ...o, fulfillerStatus: 'COMPLETED' })),
+      workspaceName: 'lab-app-test-results-form-workspace',
     });
   };
 

package/src/lab-tabs/actions/generate-bill-request-action.component.tsx

@@ -0,0 +1,46 @@
+import React, { useCallback, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Button, InlineLoading } from '@carbon/react';
+import { launchWorkspace, useConfig, type Order } from '@openmrs/esm-framework';
+import styles from './actions.scss';
+import { type Config } from '../../config-schema';
+import { type BillStatus } from '../../types';
+
+interface GenerateBillRequestActionMenuProps {
+  order: Order;
+  billStatus: BillStatus;
+  isLoading: boolean;
+  mutated: () => void;
+}
+
+const GenerateBillRequestAction: React.FC<GenerateBillRequestActionMenuProps> = ({
+  order,
+  billStatus = 'BLANK',
+  isLoading,
+  mutated,
+}) => {
+  const { t } = useTranslation();
+  const { laboratoryServiceTypedUuid } = useConfig<Config>();
+
+  const launchBillWorkspace = () => {
+    launchWorkspace('create-order-bill-form-workspace', {
+      workspaceTitle: t('createOrderBill', 'Create order bill form'),
+      order,
+      quantity: 1,
+      serviceTypeUuid: laboratoryServiceTypedUuid,
+      mutated,
+    });
+  };
+
+  return billStatus === 'PENDING' ? (
+    <Button className={styles.actionButton} size="sm" kind="danger" key={order.uuid}>
+      {t('pendingPayment', 'Pending payment')}
+    </Button>
+  ) : billStatus === 'BLANK' ? (
+    <Button className={styles.actionButton} size="sm" kind="primary" key={order.uuid} onClick={launchBillWorkspace}>
+      {t('generateBill', 'Generate bill')}
+    </Button>
+  ) : null;
+};
+
+export default GenerateBillRequestAction;

package/src/lab-tabs/actions/pickup-lab-request-action.component.tsx

@@ -1,14 +1,16 @@
-import React, { useCallback } from 'react';
+import React, { useCallback, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Button } from '@carbon/react';
 import { showModal, type Order } from '@openmrs/esm-framework';
 import styles from './actions.scss';
+import { type BillStatus } from '../../types';
 
 interface PickLabRequestActionMenuProps {
   order: Order;
+  billStatus: BillStatus;
 }
 
-const PickupLabRequestAction: React.FC<PickLabRequestActionMenuProps> = ({ order }) => {
+const PickupLabRequestAction: React.FC<PickLabRequestActionMenuProps> = ({ order, billStatus = 'PAID' }) => {
   const { t } = useTranslation();
   const unsupportedStatuses = ['COMPLETED', 'DECLINED', 'IN_PROGRESS', 'ON_HOLD'];
 
@@ -19,7 +21,7 @@ const PickupLabRequestAction: React.FC<PickLabRequestActionMenuProps> = ({ order
     });
   }, [order]);
 
-  return (
+  return billStatus === 'PAID' || billStatus === 'POSTED' ? (
     <Button
       className={styles.actionButton}
       disabled={unsupportedStatuses.includes(order.fulfillerStatus)}
@@ -30,7 +32,7 @@ const PickupLabRequestAction: React.FC<PickLabRequestActionMenuProps> = ({ order
     >
       {t('pickRequest', 'Pick lab request')}
     </Button>
-  );
+  ) : null;
 };
 
 export default PickupLabRequestAction;

package/src/lab-tabs/data-table-extensions/pending-review-lab-request-table.extension.tsx

@@ -2,7 +2,7 @@ import React from 'react';
 import OrdersDataTable from '../../components/orders-table/orders-data-table.component';
 
 const PendingReviewLabRequestsTable: React.FC = () => {
-  return <OrdersDataTable fulfillerStatus="DRAFT" useFilter={false} excludeCanceledAndDiscontinuedOrders={false} />;
+  return <OrdersDataTable fulfillerStatus="ON_HOLD" useFilter={false} excludeCanceledAndDiscontinuedOrders={false} />;
 };
 
 export default PendingReviewLabRequestsTable;