@kenyaemr/esm-ward-app 8.1.2-pre.214 → 8.5.1-pre.18

package/src/ward-workspace/create-admission-encounter/create-admission-encounter.test.tsx

@@ -0,0 +1,241 @@
+import { useAppContext, useVisit } from '@openmrs/esm-framework';
+import { screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import {
+  mockInpatientAdmissions,
+  mockInpatientRequests,
+  mockLocationInpatientWard,
+  mockLocationMosoriot,
+  mockPatientAlice,
+} from '__mocks__';
+import React from 'react';
+import { renderWithSwr } from '../../../../../tools';
+import { mockWardViewContext } from '../../../mock';
+import { useAssignedBedByPatient } from '../../hooks/useAssignedBedByPatient';
+import useEmrConfiguration from '../../hooks/useEmrConfiguration';
+import { useInpatientAdmissionByPatients } from '../../hooks/useInpatientAdmissionByPatients';
+import { useInpatientRequestByPatients } from '../../hooks/useInpatientRequestByPatients';
+import useRestPatient from '../../hooks/useRestPatient';
+import useWardLocation from '../../hooks/useWardLocation';
+import { type WardViewContext } from '../../types';
+import { useAdmitPatient } from '../../ward.resource';
+import CreateAdmissionEncounterWorkspace from './create-admission-encounter.workspace';
+
+jest.mocked(useAppContext<WardViewContext>).mockReturnValue(mockWardViewContext);
+
+const mockUseVisit = jest.mocked(useVisit).mockReturnValue({
+  activeVisit: {
+    encounters: [],
+    startDatetime: new Date().toISOString(),
+    uuid: 'mock-visit',
+    visitType: { display: 'Some Visit Type', uuid: 'some-visit-type-uuid' },
+  },
+  currentVisit: null,
+  currentVisitIsRetrospective: null,
+  mutate: jest.fn(),
+  error: undefined,
+  isLoading: false,
+  isValidating: false,
+});
+
+jest.mock('../../hooks/useWardLocation', () => jest.fn());
+const mockedUseWardLocation = jest.mocked(useWardLocation);
+mockedUseWardLocation.mockReturnValue({
+  location: mockLocationInpatientWard,
+  isLoadingLocation: false,
+  errorFetchingLocation: null,
+  invalidLocation: false,
+});
+
+jest.mock('../../hooks/useRestPatient', () => jest.fn());
+const mockUseRestPatient = jest.mocked(useRestPatient).mockReturnValue({
+  patient: mockPatientAlice,
+  isLoading: false,
+  error: null,
+  isValidating: false,
+  mutate: jest.fn(),
+});
+
+jest.mock('../../hooks/useAssignedBedByPatient', () => ({
+  useAssignedBedByPatient: jest.fn(),
+}));
+// @ts-ignore - we don't need to mock the entire object
+jest.mocked(useAssignedBedByPatient).mockReturnValue({
+  data: {
+    data: {
+      results: [
+        {
+          bedId: 1,
+          bedNumber: '1',
+          bedType: null,
+          patients: [mockPatientAlice],
+          physicalLocation: mockLocationInpatientWard,
+        },
+      ],
+    },
+  },
+  isLoading: false,
+});
+
+jest.mock('../../hooks/useInpatientAdmissionByPatients', () => ({
+  useInpatientAdmissionByPatients: jest.fn(),
+}));
+const mockedUseInpatientAdmissionByPatients = jest.mocked(useInpatientAdmissionByPatients).mockReturnValue({
+  data: [],
+  hasMore: false,
+  loadMore: jest.fn(),
+  isValidating: false,
+  isLoading: false,
+  error: undefined,
+  mutate: jest.fn(),
+  totalCount: mockInpatientAdmissions.length,
+  nextUri: null,
+});
+
+jest.mock('../../hooks/useInpatientRequestByPatients', () => ({
+  useInpatientRequestByPatients: jest.fn(),
+}));
+const mockedUseInpatientRequestByPatients = jest.mocked(useInpatientRequestByPatients).mockReturnValue({
+  inpatientRequests: [],
+  hasMore: false,
+  loadMore: jest.fn(),
+  isValidating: false,
+  isLoading: false,
+  error: undefined,
+  mutate: jest.fn(),
+  totalCount: mockInpatientAdmissions.length,
+  nextUri: null,
+});
+
+jest.mock('../../hooks/useEmrConfiguration', () => jest.fn());
+jest.mocked(useEmrConfiguration).mockReturnValue({
+  isLoadingEmrConfiguration: false,
+  errorFetchingEmrConfiguration: null,
+  // @ts-ignore - we only need these keys for now
+  emrConfiguration: {
+    admissionEncounterType: {
+      uuid: 'admission-encounter-type-uuid',
+      display: 'Admission Encounter',
+    },
+    transferWithinHospitalEncounterType: {
+      uuid: 'transfer-within-hospital-encounter-type-uuid',
+      display: 'Transfer Within Hospital Encounter Type',
+    },
+    clinicianEncounterRole: {
+      uuid: 'clinician-encounter-role-uuid',
+    },
+  },
+  mutateEmrConfiguration: jest.fn(),
+});
+
+jest.mock('../../ward.resource', () => ({
+  useAdmitPatient: jest.fn(),
+  assignPatientToBed: jest.fn(),
+  removePatientFromBed: jest.fn(),
+}));
+const mockedUseAdmitPatient: ReturnType<typeof useAdmitPatient> = {
+  admitPatient: jest.fn(),
+  isLoadingEmrConfiguration: false,
+  errorFetchingEmrConfiguration: false,
+};
+jest.mocked(useAdmitPatient).mockReturnValue(mockedUseAdmitPatient);
+const mockedAdmitPatient = mockedUseAdmitPatient.admitPatient;
+// @ts-ignore - we only need these two keys for now
+mockedAdmitPatient.mockResolvedValue({
+  ok: true,
+  data: {
+    uuid: 'encounter-uuid',
+  },
+});
+
+describe('CreateAdmissionEncounterWorkspace', () => {
+  it('should render patient header and admit patient button', async () => {
+    const user = userEvent.setup();
+    renderCreateAdmissionEncounterWorkspace(mockPatientAlice.uuid);
+    expect(screen.getByText(mockPatientAlice.person?.preferredName?.display)).toBeInTheDocument();
+    const admitPatientButton = screen.getByRole('button', { name: /admit patient/i });
+    expect(admitPatientButton).toBeEnabled();
+
+    await user.click(admitPatientButton);
+    expect(mockedAdmitPatient).toHaveBeenCalledWith(expect.any(Object), 'ADMIT', 'mock-visit');
+  });
+  it('should have warning when patient has a pending admission request', async () => {
+    mockedUseInpatientRequestByPatients.mockReturnValueOnce({
+      inpatientRequests: mockInpatientRequests,
+      hasMore: false,
+      loadMore: jest.fn(),
+      isValidating: false,
+      isLoading: false,
+      error: undefined,
+      mutate: jest.fn(),
+      totalCount: mockInpatientAdmissions.length,
+      nextUri: null,
+    });
+    const user = userEvent.setup();
+    renderCreateAdmissionEncounterWorkspace(mockPatientAlice.uuid);
+    expect(screen.getByText(mockPatientAlice.person?.preferredName?.display)).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        'Patient already has a pending admission request to location ' + mockLocationInpatientWard.display,
+      ),
+    ).toBeInTheDocument();
+    const admitPatientButton = screen.getByRole('button', { name: /admit patient/i });
+    expect(admitPatientButton).toBeEnabled();
+
+    await user.click(admitPatientButton);
+    expect(mockedAdmitPatient).toHaveBeenCalledWith(expect.any(Object), 'ADMIT', 'mock-visit');
+  });
+
+  it('should have warning when patient is already admitted elsewhere', async () => {
+    mockedUseInpatientAdmissionByPatients.mockReturnValueOnce({
+      data: [{ ...mockInpatientAdmissions[0], currentInpatientLocation: mockLocationMosoriot }],
+      hasMore: false,
+      loadMore: jest.fn(),
+      isValidating: false,
+      isLoading: false,
+      error: undefined,
+      mutate: jest.fn(),
+      totalCount: mockInpatientAdmissions.length,
+      nextUri: null,
+    });
+    const user = userEvent.setup();
+    renderCreateAdmissionEncounterWorkspace(mockPatientAlice.uuid);
+    expect(screen.getByText(mockPatientAlice.person?.preferredName?.display)).toBeInTheDocument();
+    expect(screen.getByText('Patient currently admitted to ' + mockLocationMosoriot.display)).toBeInTheDocument();
+    const admitPatientButton = screen.getByRole('button', { name: /transfer patient/i });
+    expect(admitPatientButton).toBeEnabled();
+
+    await user.click(admitPatientButton);
+    expect(mockedAdmitPatient).toHaveBeenCalledWith(expect.any(Object), 'TRANSFER', 'mock-visit');
+  });
+
+  it('should disable admit patient button when patient is already admitted to current location', () => {
+    mockedUseInpatientAdmissionByPatients.mockReturnValueOnce({
+      data: mockInpatientAdmissions,
+      hasMore: false,
+      loadMore: jest.fn(),
+      isValidating: false,
+      isLoading: false,
+      error: undefined,
+      mutate: jest.fn(),
+      totalCount: mockInpatientAdmissions.length,
+      nextUri: null,
+    });
+    renderCreateAdmissionEncounterWorkspace(mockPatientAlice.uuid);
+    expect(screen.getByText(mockPatientAlice.person?.preferredName?.display)).toBeInTheDocument();
+    expect(screen.getByText('Patient already admitted to current location')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /admit patient/i })).toBeDisabled();
+  });
+});
+
+function renderCreateAdmissionEncounterWorkspace(patentUuid: string) {
+  renderWithSwr(
+    <CreateAdmissionEncounterWorkspace
+      patientUuid={patentUuid}
+      closeWorkspace={jest.fn()}
+      promptBeforeClosing={jest.fn()}
+      closeWorkspaceWithSavedChanges={jest.fn()}
+      setTitle={jest.fn()}
+    />,
+  );
+}

package/src/ward-workspace/create-admission-encounter/create-admission-encounter.workspace.tsx

@@ -0,0 +1,152 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { Button, InlineNotification, SkeletonText } from '@carbon/react';
+import { ArrowLeftIcon, type DefaultWorkspaceProps, useVisit } from '@openmrs/esm-framework';
+import { useAssignedBedByPatient } from '../../hooks/useAssignedBedByPatient';
+import { useInpatientAdmissionByPatients } from '../../hooks/useInpatientAdmissionByPatients';
+import { useInpatientRequestByPatients } from '../../hooks/useInpatientRequestByPatients';
+import useRestPatient from '../../hooks/useRestPatient';
+import useWardLocation from '../../hooks/useWardLocation';
+import type { Bed, WardPatient } from '../../types';
+import AdmitPatientButton from '../admit-patient-button.component';
+import WardPatientWorkspaceBanner from '../patient-banner/patient-banner.component';
+
+export interface CreateAdmissionEncounterWorkspaceProps {
+  patientUuid: string;
+  handleReturnToSearchList?: () => void;
+}
+
+/**
+ * This is the workspace that opens when clicking on a search result
+ * from the workspace triggered by the "Add patient to ward" button.
+ * It directly admits them to the current ward locations
+ */
+const CreateAdmissionEncounterWorkspace: React.FC<CreateAdmissionEncounterWorkspaceProps & DefaultWorkspaceProps> = ({
+  patientUuid,
+  handleReturnToSearchList,
+  closeWorkspaceWithSavedChanges,
+}) => {
+  const { location } = useWardLocation();
+  const { patient, isLoading: isLoadingPatient, error: errorLoadingPatient } = useRestPatient(patientUuid);
+  const { activeVisit, isLoading: isLoadingVisit, error: errorLoadingVisit } = useVisit(patientUuid);
+  const { t } = useTranslation();
+  const { data: bedData, isLoading: isLoadingBed, error: errorLoadingBed } = useAssignedBedByPatient(patientUuid);
+  const {
+    data: inpatientAdmissions,
+    isLoading: isLoadingInpatientAdmission,
+    error: errorInpatientAdmission,
+  } = useInpatientAdmissionByPatients([patientUuid]);
+  const {
+    inpatientRequests,
+    isLoading: isLoadingInpatientRequest,
+    error: errorInpatientRequests,
+  } = useInpatientRequestByPatients([patientUuid]);
+
+  const isLoading =
+    isLoadingPatient || isLoadingVisit || isLoadingBed || isLoadingInpatientAdmission || isLoadingInpatientRequest;
+  const hasError =
+    errorLoadingPatient || errorLoadingVisit || errorLoadingBed || errorInpatientAdmission || errorInpatientRequests;
+
+  if (isLoading) {
+    return <SkeletonText />;
+  } else if (hasError) {
+    return (
+      <div>
+        <InlineNotification
+          kind="error"
+          lowContrast={true}
+          title={t('errorLoadingPatientInfo', 'Error loading patient info')}
+        />
+        <Button
+          kind="ghost"
+          renderIcon={(props) => <ArrowLeftIcon size={24} {...props} />}
+          iconDescription={t('backToSearchResults', 'Back to search results')}
+          size="sm"
+          onClick={() => handleReturnToSearchList?.()}>
+          <span>{t('backToSearchResults', 'Back to search results')}</span>
+        </Button>
+      </div>
+    );
+  } else {
+    const assignedBedDetail = bedData.data.results[0];
+    const isAssignedBedAtCurrentLocation = assignedBedDetail?.physicalLocation?.uuid == location.uuid;
+    const isAdmittedToCurrentLocation = inpatientAdmissions[0]?.currentInpatientLocation?.uuid == location.uuid;
+    const isAdmittedToOtherLocation = inpatientAdmissions[0] && !isAdmittedToCurrentLocation;
+
+    const wardPatient: WardPatient = {
+      patient,
+      visit: activeVisit,
+      bed: isAssignedBedAtCurrentLocation
+        ? ({
+            id: assignedBedDetail.bedId,
+            bedNumber: assignedBedDetail.bedNumber,
+            bedType: assignedBedDetail.bedType,
+          } as Bed)
+        : null,
+      inpatientAdmission: inpatientAdmissions[0],
+      inpatientRequest: null,
+    };
+    return (
+      <div>
+        <WardPatientWorkspaceBanner wardPatient={wardPatient} />
+        {activeVisit ? (
+          <div>
+            {isAdmittedToCurrentLocation && (
+              <InlineNotification
+                kind="warning"
+                lowContrast={true}
+                hideCloseButton={true}
+                title={t('patientAlreadyAdmittedToCurrentLocation', 'Patient already admitted to current location')}
+              />
+            )}
+            {isAdmittedToOtherLocation && (
+              <InlineNotification
+                kind="warning"
+                lowContrast={true}
+                hideCloseButton={true}
+                title={t('patientCurrentlyAdmittedToWardLocation', 'Patient currently admitted to {{wardLocation}}', {
+                  wardLocation: inpatientAdmissions[0].currentInpatientLocation.display,
+                })}
+              />
+            )}
+            {inpatientRequests[0] && (
+              <InlineNotification
+                kind="warning"
+                lowContrast={true}
+                hideCloseButton={true}
+                title={t(
+                  'patientHasPendingAdmissionRequest',
+                  'Patient already has a pending admission request to location {{location}}',
+                  {
+                    location: inpatientRequests[0].dispositionLocation.display,
+                  },
+                )}
+              />
+            )}
+            <AdmitPatientButton
+              wardPatient={wardPatient}
+              dispositionType={inpatientAdmissions[0] ? 'TRANSFER' : 'ADMIT'}
+              onAdmitPatientSuccess={() => closeWorkspaceWithSavedChanges()}
+              disabled={isAdmittedToCurrentLocation}
+            />
+          </div>
+        ) : (
+          <div>
+            {/* TODO: This is a placeholder, and will likely change with ongoing designs with RDE */}
+            {t('patienthasNoActiveVisit', 'Patient has no active visit')}
+          </div>
+        )}
+        <Button
+          kind="ghost"
+          renderIcon={(props) => <ArrowLeftIcon size={24} {...props} />}
+          iconDescription={t('backToSearchResults', 'Back to search results')}
+          size="sm"
+          onClick={() => handleReturnToSearchList?.()}>
+          <span>{t('backToSearchResults', 'Back to search results')}</span>
+        </Button>
+      </div>
+    );
+  }
+};
+
+export default CreateAdmissionEncounterWorkspace;

package/src/ward-workspace/kenya-emr-patient-discharge/discharge-workspace-siderail.component.tsx

@@ -0,0 +1,23 @@
+import { ActionMenuButton, launchWorkspace } from '@openmrs/esm-framework';
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { Exit } from '@carbon/react/icons';
+
+const DischargeIcon = (props) => <Exit {...props} />;
+
+export default function PatientDischargeSideRailIcon() {
+  const { t } = useTranslation();
+  const handler = () => {
+    launchWorkspace('patient-care-discharge-workspace');
+  };
+
+  return (
+    <ActionMenuButton
+      getIcon={DischargeIcon}
+      label={t('discharge', 'Discharge')}
+      iconDescription={t('discharge', 'Discharge')}
+      handler={handler}
+      type="ward-patient-discharge"
+    />
+  );
+}

package/src/ward-workspace/kenya-emr-patient-discharge/patient-discharge.resource.tsx

@@ -0,0 +1,123 @@
+import {
+  type Encounter,
+  openmrsFetch,
+  type OpenmrsResource,
+  restBaseUrl,
+  showSnackbar,
+  useAppContext,
+  useSession,
+  type Visit,
+} from '@openmrs/esm-framework';
+import { useTranslation } from 'react-i18next';
+import { type WardPatient } from '../../types';
+
+export function removePatientFromBed(bedId: number, patientUuid: string) {
+  return openmrsFetch(`${restBaseUrl}/beds/${bedId}?patientUuid=${patientUuid}`, {
+    method: 'DELETE',
+  });
+}
+
+const createDischargeEncounterPayload = (
+  patientUuid: string,
+  encounterType: OpenmrsResource,
+  location: OpenmrsResource,
+  currentProvider: OpenmrsResource,
+  visitUuid: string,
+  clinicianEncounterRole: OpenmrsResource,
+) => {
+  const encounterPayload = {
+    patient: patientUuid,
+    encounterType,
+    location: location?.uuid,
+    encounterProviders: [
+      {
+        provider: currentProvider?.uuid,
+        encounterRole: clinicianEncounterRole?.uuid,
+      },
+    ],
+    obs: [],
+    visit: visitUuid,
+  };
+  return encounterPayload;
+};
+
+const createDischargeEncounter = (encounterPayload: any) => {
+  return openmrsFetch(`${restBaseUrl}/encounter`, {
+    method: 'POST',
+    body: encounterPayload,
+    headers: { 'Content-Type': 'application/json' },
+  });
+};
+
+/**
+ * Custom hook for handling patient discharge operations
+ *
+ * This hook provides functionality to discharge a patient by:
+ * 1. Creating a discharge encounter
+ * 2. Removing the patient from their bed (if applicable)
+ * 3. Updating the ward patient group details
+ *
+ * @returns {Object} An object containing the handleDischarge function
+ * @property {Function} handleDischarge - Function to handle the patient discharge process
+ */
+export const usePatientDischarge = () => {
+  const { t } = useTranslation();
+  const { wardPatientGroupDetails } =
+    useAppContext<{ wardPatientGroupDetails: { mutate: () => void } }>('ward-view-context') ?? {};
+  const session = useSession();
+
+  /**
+   * Handles the patient discharge process
+   *
+   * @param {Encounter} encounter - The current encounter
+   * @param {WardPatient} wardPatient - The ward patient information
+   * @param {Record<string, unknown>} emrConfiguration - EMR configuration containing encounter types and roles
+   * @param {Visit} visit - The current visit
+   * @returns {Promise<void>} A promise that resolves when the discharge process is complete
+   */
+  const handleDischarge = async (
+    encounter: Encounter,
+    wardPatient: WardPatient,
+    emrConfiguration: Record<string, unknown>,
+    visit: Visit,
+  ) => {
+    try {
+      const encounterPayload = createDischargeEncounterPayload(
+        wardPatient.patient.uuid,
+        emrConfiguration.exitFromInpatientEncounterType as OpenmrsResource,
+        session?.sessionLocation as OpenmrsResource,
+        session?.currentProvider as OpenmrsResource,
+        visit.uuid,
+        emrConfiguration.clinicianEncounterRole as OpenmrsResource,
+      );
+
+      const dischargeResponse = await createDischargeEncounter(encounterPayload);
+
+      if (!dischargeResponse?.ok) {
+        throw new Error('Failed to create discharge encounter');
+      }
+
+      if (wardPatient?.bed?.id) {
+        const bedRemovalResponse = await removePatientFromBed(wardPatient.bed.id, wardPatient?.patient?.uuid);
+        if (!bedRemovalResponse?.ok) {
+          throw new Error('Failed to remove patient from bed');
+        }
+      }
+
+      showSnackbar({
+        title: t('patientWasDischarged', 'Patient was discharged'),
+        kind: 'success',
+      });
+    } catch (err) {
+      showSnackbar({
+        title: t('errorDischargingPatient', 'Error discharging patient'),
+        subtitle: err instanceof Error ? err.message : 'Unknown error occurred',
+        kind: 'error',
+      });
+    } finally {
+      wardPatientGroupDetails?.mutate();
+    }
+  };
+
+  return { handleDischarge };
+};

package/src/ward-workspace/kenya-emr-patient-discharge/patient-discharge.workspace.tsx

@@ -0,0 +1,101 @@
+import React, { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { InlineLoading, InlineNotification } from '@carbon/react';
+import {
+  type DefaultWorkspaceProps,
+  type Encounter,
+  ExtensionSlot,
+  useEmrConfiguration,
+  usePatient,
+} from '@openmrs/esm-framework';
+import { usePatientDischarge } from './patient-discharge.resource';
+import { type WardPatient } from '../../types';
+
+type PatientDischargeWorkspaceProps = DefaultWorkspaceProps & {
+  readonly patientUuid: string;
+  readonly wardPatient: WardPatient;
+  readonly formUuid: string;
+  readonly dischargePatientOnSuccesfullSubmission?: boolean;
+};
+
+export function PatientDischargeWorkspace(props: PatientDischargeWorkspaceProps) {
+  const { t } = useTranslation();
+  const {
+    patientUuid,
+    closeWorkspace,
+    closeWorkspaceWithSavedChanges,
+    wardPatient,
+    promptBeforeClosing,
+    formUuid,
+    dischargePatientOnSuccesfullSubmission = true,
+  } = props;
+  const { visit: currentVisit } = wardPatient ?? {};
+  const { patient, isLoading: isLoadingPatient, error: patientError } = usePatient(patientUuid);
+  const { emrConfiguration, isLoadingEmrConfiguration, errorFetchingEmrConfiguration } = useEmrConfiguration();
+
+  const { handleDischarge } = usePatientDischarge();
+
+  const state = useMemo<Record<string, unknown>>(
+    () => ({
+      view: 'form',
+      formUuid,
+      visitUuid: currentVisit?.uuid ?? null,
+      visitTypeUuid: currentVisit?.visitType?.uuid ?? null,
+      patientUuid: patientUuid ?? null,
+      patient,
+      encounterUuid: '',
+      closeWorkspaceWithSavedChanges,
+      closeWorkspace,
+      promptBeforeClosing,
+      handlePostResponse: (encounter: Encounter) => {
+        if (dischargePatientOnSuccesfullSubmission)
+          handleDischarge(encounter, wardPatient, emrConfiguration as Record<string, unknown>, currentVisit);
+      },
+    }),
+    [
+      patientUuid,
+      currentVisit,
+      patient,
+      closeWorkspace,
+      promptBeforeClosing,
+      emrConfiguration,
+      closeWorkspaceWithSavedChanges,
+      handleDischarge,
+      dischargePatientOnSuccesfullSubmission,
+      formUuid,
+      wardPatient,
+    ],
+  );
+
+  const isLoading = isLoadingPatient || isLoadingEmrConfiguration;
+  const error = patientError || errorFetchingEmrConfiguration;
+
+  if (isLoading) {
+    return <InlineLoading description={t('loading', 'Loading')} iconDescription={t('loading', 'Loading data...')} />;
+  }
+
+  if (error) {
+    return (
+      <InlineNotification
+        aria-label={t('error', 'Error')}
+        kind="error"
+        onClose={() => {}}
+        onCloseButtonClick={() => {}}
+        statusIconDescription="notification"
+        subtitle={t('errorLoadingPatientWorkspace', 'Error loading patient workspace {{errorMessage}}', {
+          errorMessage: error?.message,
+        })}
+        title={t('error', 'Error')}
+      />
+    );
+  }
+
+  return (
+    <div>
+      {/* <pre>{JSON.stringify(currentVisit, null, 2)}</pre> */}
+      {patient && <ExtensionSlot name="form-widget-slot" state={state} />}
+    </div>
+  );
+}
+
+export default PatientDischargeWorkspace;

package/src/ward-workspace/patient-discharge/patient-discharge.workspace.tsx

@@ -1,11 +1,10 @@
 import React, { useCallback, useState } from 'react';
+import { useTranslation } from 'react-i18next';
 import { Button, ButtonSet, InlineNotification } from '@carbon/react';
 import { Exit } from '@carbon/react/icons';
-import { useTranslation } from 'react-i18next';
-import { ExtensionSlot, showSnackbar, useAppContext, useSession } from '@openmrs/esm-framework';
+import { ExtensionSlot, showSnackbar, useAppContext } from '@openmrs/esm-framework';
 import { type WardPatientWorkspaceProps, type WardViewContext } from '../../types';
 import { removePatientFromBed, useCreateEncounter } from '../../ward.resource';
-import useWardLocation from '../../hooks/useWardLocation';
 import WardPatientWorkspaceBanner from '../patient-banner/patient-banner.component';
 import styles from './patient-discharge.scss';
 
@@ -13,8 +12,6 @@ export default function PatientDischargeWorkspace(props: WardPatientWorkspacePro
   const { wardPatient, closeWorkspaceWithSavedChanges } = props;
   const { t } = useTranslation();
   const [isSubmitting, setIsSubmitting] = useState(false);
-  const { currentProvider } = useSession();
-  const { location } = useWardLocation();
   const { createEncounter, emrConfiguration, isLoadingEmrConfiguration, errorFetchingEmrConfiguration } =
     useCreateEncounter();
   const { wardPatientGroupDetails } = useAppContext<WardViewContext>('ward-view-context') ?? {};
@@ -22,7 +19,7 @@ export default function PatientDischargeWorkspace(props: WardPatientWorkspacePro
   const submitDischarge = useCallback(() => {
     setIsSubmitting(true);
 
-    createEncounter(wardPatient?.patient, emrConfiguration.exitFromInpatientEncounterType)
+    createEncounter(wardPatient?.patient, emrConfiguration.exitFromInpatientEncounterType, wardPatient?.visit.uuid)
       .then((response) => {
         if (response?.ok) {
           if (wardPatient?.bed?.id) {
@@ -51,17 +48,11 @@ export default function PatientDischargeWorkspace(props: WardPatientWorkspacePro
         closeWorkspaceWithSavedChanges();
         wardPatientGroupDetails.mutate();
       });
-  }, [
-    createEncounter,
-    wardPatient?.patient,
-    wardPatient.bed.id,
-    emrConfiguration,
-    t,
-    closeWorkspaceWithSavedChanges,
-    wardPatientGroupDetails,
-  ]);
+  }, [createEncounter, wardPatient, emrConfiguration, t, closeWorkspaceWithSavedChanges, wardPatientGroupDetails]);
 
   if (!wardPatientGroupDetails) return <></>;
+  if (!wardPatient?.visit) return <InlineNotification kind="error" title={t('noVisit', 'No visit found')} />;
+
   return (
     <div className={styles.workspaceContent}>
       <div className={styles.patientWorkspaceBanner}>