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

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}>

package/src/ward-workspace/patient-transfer-bed-swap/{patient-transfer-request-form.component.tsx → patient-admit-or-transfer-request-form.component.tsx}

@@ -1,38 +1,49 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import {
+  Button,
+  ButtonSet,
+  Form,
+  InlineNotification,
+  RadioButton,
+  RadioButtonGroup,
+  Stack,
+  TextArea,
+} from '@carbon/react';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { ResponsiveWrapper, showSnackbar, useAppContext } from '@openmrs/esm-framework';
 import classNames from 'classnames';
-import { z } from 'zod';
-import { Button, ButtonSet, Form, InlineNotification, RadioButton, RadioButtonGroup, TextArea } from '@carbon/react';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import { Controller, useForm } from 'react-hook-form';
 import { useTranslation } from 'react-i18next';
-import { zodResolver } from '@hookform/resolvers/zod';
-import { ResponsiveWrapper, showSnackbar, useAppContext, useLayoutType, useSession } from '@openmrs/esm-framework';
-import { useCreateEncounter } from '../../ward.resource';
-import type { ObsPayload, WardPatientWorkspaceProps, WardViewContext } from '../../types';
+import { z } from 'zod';
 import useWardLocation from '../../hooks/useWardLocation';
-import AdmissionPatientButton from '../admit-patient-button.component';
 import LocationSelector from '../../location-selector/location-selector.component';
+import type { ObsPayload, WardPatientWorkspaceProps, WardViewContext } from '../../types';
+import { useCreateEncounter } from '../../ward.resource';
 import styles from './patient-transfer-swap.scss';
 
-export default function PatientTransferForm({
+/**
+ * Form to fill out for:
+ * - an admitted patient without pending transfer request, to initiate a transfer request for a patient
+ * - an admitted patient with pending transfer request, to create a request to transfer elsewhere
+ * - an un-admitted patient, to create a request to admit
+ */
+export default function PatientAdmitOrTransferForm({
   closeWorkspaceWithSavedChanges,
   wardPatient,
   promptBeforeClosing,
 }: WardPatientWorkspaceProps) {
   const { t } = useTranslation();
-  const { patient, inpatientAdmission } = wardPatient ?? {};
+  const { patient, inpatientRequest, visit } = wardPatient ?? {};
   const [showErrorNotifications, setShowErrorNotifications] = useState(false);
   const [isSubmitting, setIsSubmitting] = useState(false);
   const { createEncounter, emrConfiguration, isLoadingEmrConfiguration, errorFetchingEmrConfiguration } =
     useCreateEncounter();
-  const { currentProvider } = useSession();
-  const { location } = useWardLocation();
   const dispositionsWithTypeTransfer = useMemo(
     () => emrConfiguration?.dispositions.filter(({ type }) => type === 'TRANSFER'),
     [emrConfiguration],
   );
   const { wardPatientGroupDetails } = useAppContext<WardViewContext>('ward-view-context') ?? {};
-  const responsiveSize = useLayoutType() === 'tablet' ? 'lg' : 'md';
-  const isAdmitted = inpatientAdmission != null;
+  const currentAdmission = wardPatientGroupDetails?.inpatientAdmissionsByPatientUuid?.get(patient?.uuid);
 
   const zodSchema = useMemo(
     () =>
@@ -101,7 +112,7 @@ export default function PatientTransferForm({
         });
       }
 
-      createEncounter(patient, emrConfiguration.transferRequestEncounterType, [
+      createEncounter(patient, emrConfiguration.transferRequestEncounterType, visit?.uuid, [
         {
           concept: emrConfiguration.dispositionDescriptor.dispositionSetConcept.uuid,
           groupMembers: obs,
@@ -134,6 +145,7 @@ export default function PatientTransferForm({
       patient,
       t,
       wardPatientGroupDetails,
+      visit?.uuid,
     ],
   );
 
@@ -145,30 +157,11 @@ export default function PatientTransferForm({
   if (!wardPatientGroupDetails) {
     return <></>;
   }
-  if (!isAdmitted) {
-    return (
-      <div className={styles.workspaceContent}>
-        <div className={styles.formError}>
-          <InlineNotification
-            kind="info"
-            title={t('unableToTransferPatient', 'Unable to transfer patient')}
-            subtitle={t(
-              'unableToTransferPatientNotYetAdmitted',
-              'This patient is not admitted to this ward. Admit this patient before transferring them to a different location.',
-            )}
-            lowContrast
-            hideCloseButton
-          />
-        </div>
-        <AdmissionPatientButton wardPatient={wardPatient} onAdmitPatientSuccess={closeWorkspaceWithSavedChanges} />
-      </div>
-    );
-  }
   return (
     <Form
       onSubmit={handleSubmit(onSubmit, onError)}
       className={classNames(styles.formContainer, styles.workspaceContent)}>
-      <div>
+      <Stack gap={4}>
         {errorFetchingEmrConfiguration && (
           <div className={styles.formError}>
             <InlineNotification
@@ -183,13 +176,39 @@ export default function PatientTransferForm({
             />
           </div>
         )}
+        {currentAdmission ? (
+          inpatientRequest && (
+            <InlineNotification
+              kind="info"
+              lowContrast={true}
+              hideCloseButton={true}
+              title={t('patientCurrentlyAdmittedToWardLocation', 'Patient currently admitted to {{wardLocation}}', {
+                wardLocation: currentAdmission.currentInpatientLocation.display,
+              })}
+            />
+          )
+        ) : (
+          <InlineNotification
+            kind="info"
+            lowContrast={true}
+            hideCloseButton={true}
+            title={t('patientCurrentlyNotAdmitted', 'Patient currently not admitted')}
+          />
+        )}
         <div className={styles.field}>
           <h2 className={styles.productiveHeading02}>{t('selectALocation', 'Select a location')}</h2>
           <Controller
             name="location"
             control={control}
             render={({ field, fieldState: { error } }) => (
-              <LocationSelector {...field} invalid={!!error?.message} invalidText={error?.message} />
+              <LocationSelector
+                name={field.name}
+                field={field}
+                invalid={!!error?.message}
+                invalidText={error?.message}
+                ancestorLocation={visit?.location}
+                excludeLocations={currentAdmission ? [currentAdmission.currentInpatientLocation] : []}
+              />
             )}
           />
         </div>
@@ -234,7 +253,7 @@ export default function PatientTransferForm({
             ))}
           </div>
         )}
-      </div>
+      </Stack>
       <ButtonSet className={styles.buttonSet}>
         <Button size="xl" kind="secondary" onClick={closeWorkspaceWithSavedChanges}>
           {t('cancel', 'Cancel')}

package/src/ward-workspace/patient-transfer-bed-swap/patient-bed-swap-form.component.tsx

@@ -16,7 +16,7 @@ export default function PatientBedSwapForm({
   closeWorkspaceWithSavedChanges,
   wardPatient,
 }: WardPatientWorkspaceProps) {
-  const { patient } = wardPatient;
+  const { patient, visit } = wardPatient;
   const { t } = useTranslation();
   const [showErrorNotifications, setShowErrorNotifications] = useState(false);
   const { createEncounter, emrConfiguration, isLoadingEmrConfiguration, errorFetchingEmrConfiguration } =
@@ -56,7 +56,7 @@ export default function PatientBedSwapForm({
       const bedSelected = beds.find((bed) => bed.bedId === values.bedId);
       setIsSubmitting(true);
       setShowErrorNotifications(false);
-      createEncounter(patient, emrConfiguration.bedAssignmentEncounterType)
+      createEncounter(patient, emrConfiguration.bedAssignmentEncounterType, visit.uuid)
         .then(async (response) => {
           if (response.ok) {
             if (bedSelected) {
@@ -110,7 +110,16 @@ export default function PatientBedSwapForm({
           closeWorkspaceWithSavedChanges();
         });
     },
-    [beds, createEncounter, patient, emrConfiguration, t, wardPatientGroupDetails, closeWorkspaceWithSavedChanges],
+    [
+      beds,
+      createEncounter,
+      patient,
+      emrConfiguration,
+      t,
+      wardPatientGroupDetails,
+      closeWorkspaceWithSavedChanges,
+      visit?.uuid,
+    ],
   );
 
   const onError = useCallback(() => {
@@ -118,6 +127,7 @@ export default function PatientBedSwapForm({
   }, []);
 
   if (!wardPatientGroupDetails) return <></>;
+  if (!visit) return <InlineNotification kind="error" title={t('noVisit', 'No visit found')} />;
   return (
     <Form
       onSubmit={handleSubmit(onSubmit, onError)}