@ampath/esm-dha-workflow-app 4.0.0-next.44 → 4.0.0-next.448

package/src/specialized-clinics/psychiatry/queues/consultation/psychiatry-consultation.tsx

@@ -0,0 +1,15 @@
+import React from 'react';
+import ServiceQueueComponent from '../../../../service-queues/service-queue/service-queue.component';
+import { QUEUE_SERVICE_UUIDS } from '../../../../shared/constants/concepts';
+
+interface PsychiatryConsultationProps {}
+const PsychiatryConsultation: React.FC<PsychiatryConsultationProps> = () => {
+  return (
+    <>
+      <div>
+        <ServiceQueueComponent serviceTypeUuid={QUEUE_SERVICE_UUIDS.PSYCHIATRY_CONSULTATION_SERVICE_UUID} title="Psychiatry Consultation" />
+      </div>
+    </>
+  );
+};
+export default PsychiatryConsultation;

package/src/specialized-clinics/psychiatry/queues/triage/psychiatry-triage.tsx

@@ -0,0 +1,15 @@
+import React from 'react';
+import ServiceQueueComponent from '../../../../service-queues/service-queue/service-queue.component';
+import { QUEUE_SERVICE_UUIDS } from '../../../../shared/constants/concepts';
+
+interface PsychiatryTriageProps {}
+const PsychiatryTriage: React.FC<PsychiatryTriageProps> = () => {
+  return (
+    <>
+      <div>
+        <ServiceQueueComponent serviceTypeUuid={QUEUE_SERVICE_UUIDS.PSYCHIATRY_TRIAGE_SERVICE_UUID} title="Psychiatry Triage" />
+      </div>
+    </>
+  );
+};
+export default PsychiatryTriage;

package/src/specialized-clinics/renal/queues/consultation/dialysis-consultation.tsx

@@ -0,0 +1,15 @@
+import React from 'react';
+import ServiceQueueComponent from '../../../../service-queues/service-queue/service-queue.component';
+import { QUEUE_SERVICE_UUIDS } from '../../../../shared/constants/concepts';
+
+interface RenalConsultationProps {}
+const RenalConsultation: React.FC<RenalConsultationProps> = () => {
+  return (
+    <>
+      <div>
+        <ServiceQueueComponent serviceTypeUuid={QUEUE_SERVICE_UUIDS.DIALYSIS_CONSULTATION_SERVICE_UUID} title="Renal Consultation" />
+      </div>
+    </>
+  );
+};
+export default RenalConsultation;

package/src/specialized-clinics/renal/queues/triage/renal-triage.tsx

@@ -0,0 +1,15 @@
+import React from 'react';
+import ServiceQueueComponent from '../../../../service-queues/service-queue/service-queue.component';
+import { QUEUE_SERVICE_UUIDS } from '../../../../shared/constants/concepts';
+
+interface RenalTriageProps {}
+const RenalTriage: React.FC<RenalTriageProps> = () => {
+  return (
+    <>
+      <div>
+        <ServiceQueueComponent serviceTypeUuid={QUEUE_SERVICE_UUIDS.DIALYSIS_TRIAGE_SERVICE_UUID} title="Renal Triage" />
+      </div>
+    </>
+  );
+};
+export default RenalTriage;

package/src/specialized-clinics/renal/renal-queues.component.scss

@@ -0,0 +1,7 @@
+.renalLayout{
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    row-gap: 10px;
+    padding: 2% 2%;
+}

package/src/specialized-clinics/renal/renal-queues.component.tsx

@@ -0,0 +1,36 @@
+import React from 'react';
+import styles from './renal-queues.component.scss';
+import { Tab, TabList, TabPanel, TabPanels, Tabs } from '@carbon/react';
+import FacilityAndWorkerSlot from '../../shared/ui/facility-worker-slot/facility-worker.component-slot.component';
+import RenalTriage from './queues/triage/renal-triage';
+import RenalConsultation from './queues/consultation/dialysis-consultation';
+interface RenalQueuesProps {}
+const RenalQueues: React.FC<RenalQueuesProps> = () => {
+  return (
+    <div className={styles.renalLayout}>
+      <div className={styles.hwrSection}>
+            <FacilityAndWorkerSlot />
+      </div>
+      <div className={styles.renalHeader}>
+        <h4>Renal</h4>
+      </div>
+      <div className={styles.renalContent}>
+        <Tabs>
+          <TabList contained>
+            <Tab>Triage</Tab>
+            <Tab>Consultation</Tab>
+          </TabList>
+          <TabPanels>
+            <TabPanel>
+              <RenalTriage />
+            </TabPanel>
+            <TabPanel>
+              <RenalConsultation/>
+            </TabPanel>
+          </TabPanels>
+        </Tabs>
+      </div>
+    </div>
+  );
+};
+export default RenalQueues;

package/src/specialized-clinics/specialized-clinics-root.tsx

@@ -0,0 +1,25 @@
+import React from 'react';
+import { BrowserRouter, Route, Routes } from 'react-router-dom';
+import OncologyQueues from './oncology/oncology-queues.component';
+import DentalQueues from './dental/dental-queues.component';
+import DiagnosticAndImagingQueues from './diagnostic-and-imaging/diagnostic-and-imaging.component';
+import OphthalmologyQueues from './ophthalmology/ophthalmology-queues.component';
+import PsychiatryQueues from './psychiatry/psychiatry-queues.component';
+import RenalQueues from './renal/renal-queues.component';
+
+const SpecializedClinicsRoot: React.FC = () => {
+  return (
+    <BrowserRouter basename={`${window.spaBase}/home/specialized-clinics`}>
+      <Routes>
+        <Route path="/renal" element={<RenalQueues/>} />
+        <Route path="/oncology" element={<OncologyQueues />} />
+        <Route path="/dental" element={<DentalQueues />} />
+        <Route path="/diagnostic-and-imaging" element={<DiagnosticAndImagingQueues />} />
+        <Route path="/ophthalmology" element={<OphthalmologyQueues />} />
+        <Route path="/psychiatry" element={<PsychiatryQueues />} />
+      </Routes>
+    </BrowserRouter>
+  );
+};
+
+export default SpecializedClinicsRoot;

package/src/telemedicine/telemedicine-patient-chart.component.test.tsx

@@ -0,0 +1,123 @@
+/**
+ * Rendering tests for the patient-chart telemedicine tab — the patient-scoped
+ * sibling of the home dashboard. What differs from the home flow is the mint
+ * input: the broker must receive the doctor's **and** the patient's national
+ * IDs, plus the active visit's claim consent token when there is one (it is
+ * optional — a visit without a claim consent still gets a session). These pin
+ * down that parameter assembly and the two no-national-ID cards; the session
+ * machine itself is covered by `telemedicine.component.test.tsx`.
+ */
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+
+import TelemedicinePatientChart from './telemedicine-patient-chart.component';
+
+const mockUsePatient = jest.fn();
+const mockUseSession = jest.fn();
+const mockUseVisit = jest.fn();
+const mockGetNationalId = jest.fn();
+const mockGetPatientNationalId = jest.fn();
+const mockFetchSession = jest.fn();
+
+jest.mock('@openmrs/esm-framework', () => ({
+  usePatient: () => mockUsePatient(),
+  useSession: () => mockUseSession(),
+  useVisit: () => mockUseVisit(),
+}));
+
+jest.mock('./telemedicine.resource', () => ({
+  getPractitionerNationalId: (...args: unknown[]) => mockGetNationalId(...args),
+  fetchPatientTelemedicineSession: (...args: unknown[]) => mockFetchSession(...args),
+}));
+
+jest.mock('../shr/shr.resource', () => ({
+  getPatientCrIdentifier: (...args: unknown[]) => mockGetPatientNationalId(...args),
+}));
+
+const PATIENT_UUID = '0b355dd8-de45-4142-a9c5-496b923e6be4';
+const PROVIDER_UUID = 'e2bfaf3b-9bcb-4a20-9e9e-8db9dabc8f4e';
+const LOCATION_UUID = '18c343eb-b353-462a-9139-b16606e6b6c2';
+const NATIONAL_ID_TYPE = '58a47054-1359-11df-a1f1-0026b9348838';
+const CONSENT_ATTRIBUTE = '4962a633-c4f8-474c-857c-5c68c72fbbe3';
+
+beforeEach(() => {
+  jest.resetAllMocks();
+  mockUsePatient.mockReturnValue({ patient: { id: PATIENT_UUID }, isLoading: false });
+  mockUseSession.mockReturnValue({
+    sessionLocation: { uuid: LOCATION_UUID },
+    currentProvider: { uuid: PROVIDER_UUID },
+  });
+  mockUseVisit.mockReturnValue({ activeVisit: undefined });
+  mockGetNationalId.mockResolvedValue('10000000003');
+  mockGetPatientNationalId.mockResolvedValue('87654321');
+});
+
+describe('Telemedicine patient-chart tab', () => {
+  it('mints the session with both national IDs and the visit consent token', async () => {
+    mockUseVisit.mockReturnValue({
+      activeVisit: { attributes: [{ attributeType: { uuid: CONSENT_ATTRIBUTE }, value: 'abc123' }] },
+    });
+    mockFetchSession.mockResolvedValueOnce({
+      expires_in: 600,
+      redirect_url: 'https://md-uat.liviaapp.net/#/sso?token=p4713n7',
+    });
+
+    render(<TelemedicinePatientChart />);
+
+    const iframe = await screen.findByTitle('Telemedicine');
+    expect(iframe).toHaveAttribute('src', 'https://md-uat.liviaapp.net/#/sso?token=p4713n7');
+    expect(iframe).toHaveAttribute('allow', 'camera; microphone; display-capture; fullscreen');
+    expect(mockGetNationalId).toHaveBeenCalledWith(PROVIDER_UUID);
+    expect(mockGetPatientNationalId).toHaveBeenCalledWith(PATIENT_UUID, NATIONAL_ID_TYPE);
+    expect(mockFetchSession).toHaveBeenCalledWith({
+      doctorNationalId: '10000000003',
+      patientNationalId: '87654321',
+      locationUuid: LOCATION_UUID,
+      consentToken: 'abc123',
+    });
+  });
+
+  it('still mints a session when the visit has no consent token', async () => {
+    mockFetchSession.mockResolvedValueOnce({
+      expires_in: 600,
+      redirect_url: 'https://md-uat.liviaapp.net/#/sso?token=p4713n7',
+    });
+
+    render(<TelemedicinePatientChart />);
+
+    await screen.findByTitle('Telemedicine');
+    expect(mockFetchSession).toHaveBeenCalledWith({
+      doctorNationalId: '10000000003',
+      patientNationalId: '87654321',
+      locationUuid: LOCATION_UUID,
+      consentToken: undefined,
+    });
+  });
+
+  it('says so when the patient has no national ID', async () => {
+    mockGetPatientNationalId.mockResolvedValueOnce('');
+
+    render(<TelemedicinePatientChart />);
+
+    expect(await screen.findByText('No national ID on the patient’s record')).toBeInTheDocument();
+    expect(mockFetchSession).not.toHaveBeenCalled();
+  });
+
+  it('says so when the provider account has no national ID', async () => {
+    mockGetNationalId.mockResolvedValueOnce('');
+
+    render(<TelemedicinePatientChart />);
+
+    expect(await screen.findByText('No national ID on your provider account')).toBeInTheDocument();
+    expect(mockFetchSession).not.toHaveBeenCalled();
+  });
+
+  it('says so when no patient is in context', () => {
+    mockUsePatient.mockReturnValue({ patient: undefined, isLoading: false });
+
+    render(<TelemedicinePatientChart />);
+
+    expect(screen.getByText('No patient selected')).toBeInTheDocument();
+    expect(mockFetchSession).not.toHaveBeenCalled();
+  });
+});

package/src/telemedicine/telemedicine-patient-chart.component.tsx

@@ -0,0 +1,131 @@
+import React, { useCallback, useMemo } from 'react';
+import { InlineLoading } from '@carbon/react';
+import { DocumentBlank } from '@carbon/react/icons';
+import { usePatient, useSession, useVisit } from '@openmrs/esm-framework';
+import { useTranslation } from 'react-i18next';
+import { IdentifierTypesUuids } from '../resources/identifier-types';
+import { getPatientCrIdentifier } from '../shr/shr.resource';
+import {
+  fetchPatientTelemedicineSession,
+  getPractitionerNationalId,
+} from './telemedicine.resource';
+import {
+  StatusCard,
+  TelemedicineView,
+  useTelemedicineSession,
+  type TelemedicineStartResult,
+} from './telemedicine.component';
+import styles from './telemedicine.scss';
+
+/** The visit attribute the claims flow stamps the consent token on. */
+const CLAIM_CONSENT_TOKEN_ATTRIBUTE_UUID = '4962a633-c4f8-474c-857c-5c68c72fbbe3';
+
+/**
+ * Telemedicine tab for the patient chart.
+ *
+ * The patient-scoped sibling of the home-page dashboard: the minted session is
+ * for this consult — Livia keys it on the doctor's and the patient's national
+ * IDs — and the visit's claim consent token rides along when there is one
+ * (optional; a visit without a claim consent still gets a session). Everything
+ * else — the brokered SSO, the iframe, the reconnect flow — is the shared
+ * machine in `telemedicine.component.tsx`.
+ */
+const TelemedicinePatientChart: React.FC = () => {
+  const { t } = useTranslation();
+  const { patient, isLoading: isPatientLoading } = usePatient();
+  const session = useSession();
+
+  const patientUuid = patient?.id ?? '';
+  const locationUuid = session?.sessionLocation?.uuid ?? '';
+  const providerUuid = session?.currentProvider?.uuid ?? '';
+  const { activeVisit } = useVisit(patientUuid);
+
+  const consentToken = useMemo(
+    () =>
+      activeVisit?.attributes?.find((a) => a?.attributeType?.uuid === CLAIM_CONSENT_TOKEN_ATTRIBUTE_UUID)?.value ??
+      '',
+    [activeVisit],
+  );
+
+  const start = useCallback(async (): Promise<TelemedicineStartResult> => {
+    const [doctorNationalId, patientNationalId] = await Promise.all([
+      getPractitionerNationalId(providerUuid),
+      getPatientCrIdentifier(patientUuid, IdentifierTypesUuids.NATIONAL_ID_UUID),
+    ]);
+    if (!doctorNationalId) {
+      return { phase: 'no-national-id', scope: 'provider' };
+    }
+    if (!patientNationalId) {
+      return { phase: 'no-national-id', scope: 'patient' };
+    }
+    const sso = await fetchPatientTelemedicineSession({
+      doctorNationalId,
+      patientNationalId,
+      locationUuid,
+      // undefined drops out of the JSON body — the token is optional.
+      consentToken: consentToken || undefined,
+    });
+    return { phase: 'in-session', redirectUrl: sso?.redirect_url ?? '', expiresIn: sso?.expires_in ?? 0 };
+  }, [patientUuid, locationUuid, providerUuid, consentToken]);
+
+  const telemedicine = useTelemedicineSession(
+    start,
+    Boolean(patientUuid && locationUuid && providerUuid),
+  );
+
+  if (isPatientLoading && !patientUuid) {
+    return (
+      <div className={styles.container}>
+        <div className={styles.statusView}>
+          <InlineLoading description={t('loadingPatient', 'Loading patient…')} />
+        </div>
+      </div>
+    );
+  }
+
+  if (!patientUuid) {
+    return (
+      <div className={styles.container}>
+        <StatusCard
+          icon={<DocumentBlank size={32} className={styles.iconMuted} />}
+          title={t('noPatientSelected', 'No patient selected')}
+          text={t('telemedicineNeedsPatient', 'Open a patient chart to start a telemedicine session.')}
+        />
+      </div>
+    );
+  }
+
+  if (!locationUuid) {
+    return (
+      <div className={styles.container}>
+        <StatusCard
+          icon={<DocumentBlank size={32} className={styles.iconMuted} />}
+          title={t('noLoginLocation', 'No login location selected')}
+          text={t(
+            'telemedicineNeedsLocation',
+            'A telemedicine session must be scoped to a facility. Log in with a facility location and try again.',
+          )}
+        />
+      </div>
+    );
+  }
+
+  if (!providerUuid) {
+    return (
+      <div className={styles.container}>
+        <StatusCard
+          icon={<DocumentBlank size={32} className={styles.iconMuted} />}
+          title={t('telemedicineNoProvider', "Couldn't identify the logged-in provider")}
+          text={t(
+            'telemedicineNoProviderDetail',
+            'Your session has no provider attached, so a telemedicine session cannot be started. Log in with a provider account.',
+          )}
+        />
+      </div>
+    );
+  }
+
+  return <TelemedicineView session={telemedicine} />;
+};
+
+export default TelemedicinePatientChart;

package/src/telemedicine/telemedicine.component.test.tsx

@@ -0,0 +1,113 @@
+/**
+ * Rendering tests for the telemedicine dashboard's state machine: the
+ * missing-provider and missing-national-ID cards, the error card carrying the
+ * broker's message, and the in-session iframe fed by the minted SSO URL. The
+ * SSO keys on the practitioner's national ID, so the lookup goes to the
+ * session's provider, not the patient. The broker call itself is covered in
+ * `telemedicine.resource.test.ts`.
+ */
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+
+import Telemedicine from './telemedicine.component';
+
+const mockUseSession = jest.fn();
+const mockGetNationalId = jest.fn();
+const mockFetchSession = jest.fn();
+
+jest.mock('@openmrs/esm-framework', () => ({
+  useSession: () => mockUseSession(),
+}));
+
+jest.mock('./telemedicine.resource', () => ({
+  getPractitionerNationalId: (...args: unknown[]) => mockGetNationalId(...args),
+  fetchTelemedicineSession: (...args: unknown[]) => mockFetchSession(...args),
+}));
+
+const PROVIDER_UUID = 'e2bfaf3b-9bcb-4a20-9e9e-8db9dabc8f4e';
+const LOCATION_UUID = '18c343eb-b353-462a-9139-b16606e6b6c2';
+
+beforeEach(() => {
+  jest.resetAllMocks();
+  mockUseSession.mockReturnValue({
+    sessionLocation: { uuid: LOCATION_UUID },
+    currentProvider: { uuid: PROVIDER_UUID },
+  });
+});
+
+describe('Telemedicine dashboard', () => {
+  it('renders the consult iframe from the minted SSO URL, with a reconnect action', async () => {
+    mockGetNationalId.mockResolvedValueOnce('10000000003');
+    mockFetchSession.mockResolvedValueOnce({
+      expires_in: 600,
+      redirect_url: 'https://md-uat.liviaapp.net/#/sso?token=t0k3n',
+    });
+
+    render(<Telemedicine />);
+
+    const iframe = await screen.findByTitle('Telemedicine');
+    expect(iframe).toHaveAttribute('src', 'https://md-uat.liviaapp.net/#/sso?token=t0k3n');
+    // A video consult is useless without camera/mic — the iframe must ask the
+    // browser to delegate them to the framed app.
+    expect(iframe).toHaveAttribute('allow', 'camera; microphone; display-capture; fullscreen');
+    expect(iframe).toHaveAttribute('referrerpolicy', 'strict-origin');
+    expect(screen.getByRole('button', { name: 'Reconnect' })).toBeInTheDocument();
+    // The broker got the practitioner's national ID and the facility — the
+    // session is the health worker's, scoped to where they logged in.
+    expect(mockGetNationalId).toHaveBeenCalledWith(PROVIDER_UUID);
+    expect(mockFetchSession).toHaveBeenCalledWith({ nationalId: '10000000003', locationUuid: LOCATION_UUID });
+  });
+
+  it('says so when the provider account has no national ID', async () => {
+    mockGetNationalId.mockResolvedValueOnce('');
+
+    render(<Telemedicine />);
+
+    expect(await screen.findByText('No national ID on your provider account')).toBeInTheDocument();
+    expect(mockFetchSession).not.toHaveBeenCalled();
+  });
+
+  it('says so when the session has no provider attached', () => {
+    mockUseSession.mockReturnValue({ sessionLocation: { uuid: LOCATION_UUID }, currentProvider: undefined });
+
+    render(<Telemedicine />);
+
+    expect(screen.getByText("Couldn't identify the logged-in provider")).toBeInTheDocument();
+    expect(mockGetNationalId).not.toHaveBeenCalled();
+  });
+
+  it('shows the broker failure with its message and a retry', async () => {
+    mockGetNationalId.mockResolvedValueOnce('10000000003');
+    mockFetchSession.mockRejectedValueOnce(new Error('No telemedicine facility is configured for this location.'));
+
+    render(<Telemedicine />);
+
+    expect(await screen.findByText('No telemedicine facility is configured for this location.')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Retry' })).toBeInTheDocument();
+  });
+
+  it('fails loudly when the broker answers without a session link', async () => {
+    // A 2xx gateway fallback page parses to no data at all — the tab must
+    // not fall through to an empty "in-session" view.
+    mockGetNationalId.mockResolvedValueOnce('10000000003');
+    mockFetchSession.mockResolvedValueOnce(undefined);
+
+    render(<Telemedicine />);
+
+    expect(await screen.findByText('The telemedicine service did not return a session link.')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Retry' })).toBeInTheDocument();
+    expect(screen.queryByTitle('Telemedicine')).not.toBeInTheDocument();
+  });
+
+  it('refuses to start without a login location', () => {
+    mockUseSession.mockReturnValue({
+      sessionLocation: undefined,
+      currentProvider: { uuid: PROVIDER_UUID },
+    });
+
+    render(<Telemedicine />);
+
+    expect(screen.getByText('No login location selected')).toBeInTheDocument();
+    expect(mockGetNationalId).not.toHaveBeenCalled();
+  });
+});