@digihmis/esm-outpatient-app 1.0.3 → 1.0.5

package/src/patient-management/results/results.resource.ts

@@ -0,0 +1,150 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import useSWR from 'swr';
+
+/** A single named observation captured against a lab order (concept → value). */
+export interface LabResultValue {
+  concept?: { uuid: string; display: string };
+  value?: string | number | { uuid: string; display: string };
+  obsDatetime?: string;
+}
+
+/** One completed lab test order together with its result observations. */
+export interface LabResultRecord {
+  orderUuid: string;
+  orderNumber?: string;
+  testName: string;
+  date?: string;
+  results: Array<LabResultValue>;
+}
+
+/** A radiology/procedure study record (shared Procedure entity in the orders module). */
+export interface ProcedureRecord {
+  uuid: string;
+  status?: string;
+  startDatetime?: string;
+  orderUuid?: string;
+  concept?: { uuid: string; display: string };
+  preliminaryReport?: string;
+  procedureReport?: string;
+  impressions?: string;
+}
+
+const PROCEDURE_REP =
+  'custom:(uuid,status,startDatetime,orderUuid,concept:(uuid,display),preliminaryReport,procedureReport,impressions)';
+
+/**
+ * All radiology/procedure studies for a patient (both Imaging and Procedure — the caller splits them
+ * by concept-set membership). Newest first.
+ */
+export function useProcedureRecords(patientUuid: string) {
+  const url = patientUuid
+    ? `${restBaseUrl}/digihmisorders/procedure?patient=${patientUuid}&v=${PROCEDURE_REP}`
+    : null;
+  const { data, error, isLoading, mutate } = useSWR<{ data: { results: Array<ProcedureRecord> } }>(url, openmrsFetch);
+  const procedures = (data?.data?.results ?? [])
+    .slice()
+    .sort((a, b) => (b.startDatetime ?? '').localeCompare(a.startDatetime ?? ''));
+  return { procedures, error, isLoading, mutate };
+}
+
+/**
+ * The flattened set of concept uuids belonging to a concept set (recursing up to three levels of
+ * nested sets — enough for the curated radiology set). Used to decide Imaging vs Procedure.
+ */
+export function useConceptSetMembers(setUuid: string): Set<string> {
+  const url = setUuid
+    ? `${restBaseUrl}/concept/${setUuid}?v=custom:(setMembers:(uuid,setMembers:(uuid,setMembers:(uuid))))`
+    : null;
+  const { data } = useSWR<{ data: { setMembers: Array<NestedConcept> } }>(url, openmrsFetch);
+  const members = new Set<string>();
+  collectMembers(data?.data?.setMembers, members);
+  return members;
+}
+
+interface NestedConcept {
+  uuid: string;
+  setMembers?: Array<NestedConcept>;
+}
+
+function collectMembers(nodes: Array<NestedConcept> | undefined, acc: Set<string>): void {
+  for (const node of nodes ?? []) {
+    if (node?.uuid) {
+      acc.add(node.uuid);
+    }
+    if (node?.setMembers?.length) {
+      collectMembers(node.setMembers, acc);
+    }
+  }
+}
+
+/**
+ * The patient's completed lab test orders with their result observations. Fetches the patient's
+ * orders, keeps the completed Test Orders, then pulls each order's results from the labresult
+ * endpoint. Newest first.
+ */
+export function useLabResults(patientUuid: string) {
+  const ordersUrl = patientUuid
+    ? `${restBaseUrl}/order?patient=${patientUuid}&v=custom:(uuid,orderNumber,dateActivated,fulfillerStatus,action,concept:(display),orderType:(uuid,display))`
+    : null;
+
+  const { data, error, isLoading, mutate } = useSWR<Array<LabResultRecord>>(
+    ordersUrl,
+    async (url: string) => {
+      const response = await openmrsFetch<{ results: Array<LabOrder> }>(url);
+      const orders = response?.data?.results ?? [];
+      const testOrders = orders.filter(
+        (order) =>
+          order?.orderType?.display?.toLowerCase().includes('test') &&
+          order?.fulfillerStatus === 'COMPLETED' &&
+          order?.action !== 'DISCONTINUE',
+      );
+
+      const records = await Promise.all(
+        testOrders.map(async (order): Promise<LabResultRecord> => {
+          const base: LabResultRecord = {
+            orderUuid: order.uuid,
+            orderNumber: order.orderNumber,
+            testName: order?.concept?.display ?? order?.orderNumber ?? 'Test',
+            date: order.dateActivated,
+            results: [],
+          };
+          try {
+            const res = await openmrsFetch<{ results: Array<LabResultValue> }>(
+              `${restBaseUrl}/digihmisorders/labresult/${order.uuid}`,
+            );
+            return { ...base, results: res?.data?.results ?? [] };
+          } catch {
+            // A single order's results failing must not blank the whole tab.
+            return base;
+          }
+        }),
+      );
+
+      return records.sort((a, b) => (b.date ?? '').localeCompare(a.date ?? ''));
+    },
+    { revalidateOnFocus: false },
+  );
+
+  return { labResults: data ?? [], error, isLoading, mutate };
+}
+
+interface LabOrder {
+  uuid: string;
+  orderNumber?: string;
+  dateActivated?: string;
+  fulfillerStatus?: string;
+  action?: string;
+  concept?: { display: string };
+  orderType?: { uuid: string; display: string };
+}
+
+/** Render an obs value that may be a scalar or a coded {uuid,display}. */
+export function formatLabValue(value: LabResultValue['value']): string {
+  if (value == null) {
+    return '—';
+  }
+  if (typeof value === 'object') {
+    return value.display ?? '—';
+  }
+  return String(value);
+}

package/src/queue-room-table/queue-room-table.component.tsx

@@ -18,7 +18,7 @@ import {
 import { CheckmarkFilled, Time } from '@carbon/react/icons';
 import { useTranslation } from 'react-i18next';
 import { isDesktop, launchWorkspace, navigate, showSnackbar, useConfig, useLayoutType } from '@openmrs/esm-framework';
-import { useQueueEntries } from './queue-room-table.resource';
+import { useQueueEntries, isReturnedEntry } from './queue-room-table.resource';
 import { useQueueActions } from './useQueueActions';
 import styles from './queue-room-table.scss';
 import { type QueueEntry } from './type';
@@ -55,7 +55,8 @@ export const QueueRoomTable: React.FC<QueueRoomTableProps> = ({ queueRoomUuid, q
       (entry) =>
         entry?.patient?.display.toLowerCase().includes(search) ||
         entry?.display.toLowerCase().includes(search) ||
-        entry?.queueRoomComingFrom?.display?.toLowerCase().includes(search),
+        entry?.queueRoomComingFrom?.display?.toLowerCase().includes(search) ||
+        entry?.queueComingFrom?.display?.toLowerCase().includes(search),
     );
   }, [queueEntries, searchTerm]);
 
@@ -144,7 +145,7 @@ export const QueueRoomTable: React.FC<QueueRoomTableProps> = ({ queueRoomUuid, q
       patientUuid: patientUuid,
       age: entry?.patient?.person?.age,
       gender: entry?.patient?.person?.gender === 'M' ? t('male', 'Male') : t('female', 'Female'),
-      comingFrom: entry?.queueRoomComingFrom?.display || t('direct', 'Direct Entry'),
+      comingFrom: entry?.queueRoomComingFrom?.display || entry?.queueComingFrom?.display || t('direct', 'Direct Entry'),
       priority: entry?.priority?.display || t('normal', 'Normal'),
       priorityColor: getPriorityColor(entry?.priority?.display || ''),
       waitTime: calculateWaitTime(entry?.startedAt),
@@ -203,8 +204,14 @@ export const QueueRoomTable: React.FC<QueueRoomTableProps> = ({ queueRoomUuid, q
                 </TableRow>
               </TableHead>
               <TableBody>
-                {rows.map((row) => (
-                  <TableRow key={row.id} {...getRowProps({ row })}>
+                {rows.map((row) => {
+                  const rowEntry = row.cells.find((c) => c.info.header === 'entry')?.value as QueueEntry;
+                  const returned = isReturnedEntry(rowEntry);
+                  return (
+                  <TableRow
+                    key={row.id}
+                    {...getRowProps({ row })}
+                    className={returned ? styles.returnedRow : undefined}>
                     {row.cells.map((cell) => {
                       if (
                         ['statusUuid', 'patientUuid', 'entryUuid', 'priorityColor', 'entry'].includes(cell.info.header)
@@ -225,9 +232,13 @@ export const QueueRoomTable: React.FC<QueueRoomTableProps> = ({ queueRoomUuid, q
                       if (cell.info.header === 'priority') {
                         return (
                           <TableCell key={cell.id}>
-                            <Tag type={row.cells.find((c) => c.info.header === 'priorityColor')?.value}>
-                              {cell.value}
-                            </Tag>
+                            {returned ? (
+                              <Tag type="teal">{t('returned', 'Returned')}</Tag>
+                            ) : (
+                              <Tag type={row.cells.find((c) => c.info.header === 'priorityColor')?.value}>
+                                {cell.value}
+                              </Tag>
+                            )}
                           </TableCell>
                         );
                       }
@@ -291,7 +302,8 @@ export const QueueRoomTable: React.FC<QueueRoomTableProps> = ({ queueRoomUuid, q
                       return <TableCell key={cell.id}>{cell.value}</TableCell>;
                     })}
                   </TableRow>
-                ))}
+                  );
+                })}
               </TableBody>
             </Table>
           </TableContainer>

package/src/queue-room-table/queue-room-table.resource.ts

@@ -2,9 +2,19 @@ import { FetchResponse, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework
 import useSWR from 'swr';
 import { type QueueEntry } from './type';
 
+/**
+ * A "returned" entry is a patient sent back to the consultation queue after all their ordered
+ * investigations completed. The backend stamps such entries with a priorityComment of the form
+ * "All N investigations complete - Results ready for review" and a queueComingFrom pointing at the
+ * department they just finished. We surface these distinctly (own colour, ranked right after
+ * Emergency) so the clinician picks up results-ready patients first.
+ */
+export const isReturnedEntry = (entry: Pick<QueueEntry, 'priorityComment'>): boolean =>
+  !!entry?.priorityComment?.toLowerCase().includes('investigations complete');
+
 export const useQueueEntries = (queueRoomUuid: string, queueUuid: string) => {
   const customRepresentation =
-    'custom:(uuid,display,patient:(uuid,display,person:(display,age,gender)),priority:(uuid,display),status:(uuid,display),visit:(uuid),startedAt,sortWeight,queueRoom:(uuid,display),queueRoomComingFrom:(uuid,display))';
+    'custom:(uuid,display,patient:(uuid,display,person:(display,age,gender)),priority:(uuid,display),status:(uuid,display),visit:(uuid),startedAt,sortWeight,priorityComment,queueRoom:(uuid,display),queueComingFrom:(uuid,display),queueRoomComingFrom:(uuid,display))';
 
   const params = new URLSearchParams();
   params.append('v', customRepresentation);
@@ -24,18 +34,26 @@ export const useQueueEntries = (queueRoomUuid: string, queueUuid: string) => {
   );
 
   const sortedEntries = data?.data?.results?.sort((a, b) => {
+    // Emergency first, then results-ready "Returned" patients, then the usual priorities.
     const priorityOrder: Record<string, number> = {
       emergency: 0,
-      urgent: 1,
-      priority: 2,
-      normal: 3,
+      returned: 1,
+      urgent: 2,
+      priority: 3,
+      normal: 4,
     };
 
-    const aPriority = a.priority?.display?.toLowerCase() || 'normal';
-    const bPriority = b.priority?.display?.toLowerCase() || 'normal';
+    const rank = (entry: QueueEntry) => {
+      const p = entry.priority?.display?.toLowerCase() || 'normal';
+      // A returned patient outranks everything except a true emergency.
+      if (isReturnedEntry(entry) && p !== 'emergency') {
+        return priorityOrder.returned;
+      }
+      return priorityOrder[p] ?? priorityOrder.normal;
+    };
 
-    const aOrder = priorityOrder[aPriority] ?? 3;
-    const bOrder = priorityOrder[bPriority] ?? 3;
+    const aOrder = rank(a);
+    const bOrder = rank(b);
 
     if (aOrder !== bOrder) {
       return aOrder - bOrder;

package/src/queue-room-table/queue-room-table.scss

@@ -139,6 +139,23 @@
   }
 }
 
+/* Results-ready "Returned" patients: a distinct teal wash + left accent so they stand out from
+   ordinary waiting rows, even under Carbon zebra striping. Ranked right after Emergency. */
+.returnedRow {
+  &,
+  td {
+    background-color: colors.$teal-10 !important;
+  }
+
+  td:first-child {
+    box-shadow: inset 3px 0 0 0 colors.$teal-50;
+  }
+
+  &:hover td {
+    background-color: colors.$teal-20 !important;
+  }
+}
+
 .longWait {
   display: flex;
   align-items: center;

package/src/queue-room-table/type/index.ts

@@ -29,6 +29,12 @@ export interface QueueEntry {
     uuid: string;
     display: string;
   };
+  queueComingFrom?: {
+    uuid: string;
+    display: string;
+  };
   startedAt: string;
   sortWeight: number;
+  /** Free-text stamped by the backend; "…investigations complete…" marks a returned patient. */
+  priorityComment?: string;
 }

package/src/routes.json

@@ -39,7 +39,7 @@
         "name": "outpatient/patient/:patientUuid/file",
         "slot": "outpatient-file-dashboard-slot",
         "title": "Patient file",
-        "showOnlyOnRoute": "/file"
+        "showOnlyOnRoute": "/patient/"
       },
       "order": 2,
       "online": true,