@kenyaemr/esm-morgue-app 5.4.2-pre.2344 → 5.4.2-pre.2349

package/src/config-schema.ts

@@ -48,10 +48,10 @@ export const configSchema = {
     _description: 'UUID for next of kin relationship concept',
     _default: 'd0aa9fd1-2ac5-45d8-9c5e-4317c622c8f5',
   },
-  nextOfKinAddressUuid: {
+  nextOfKinNationalIdUuid: {
     _type: Type.String,
-    _description: 'UUID for next of kin address concept',
-    _default: '7cf22bec-d90a-46ad-9f48-035952261294',
+    _description: 'UUID for next of kin national ID concept',
+    _default: '73d34479-2f9e-4de3-a5e6-1f79a17459bb',
   },
   nextOfKinPhoneUuid: {
     _type: Type.String,
@@ -118,6 +118,128 @@ export const configSchema = {
     _description: 'UUID for serial number concept',
     _default: '1646AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
   },
+  receivingAreaUuid: {
+    _type: Type.String,
+    _description: 'UUID for receiving area concept',
+    _default: '159495AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
+  reasonForTransferUuid: {
+    _type: Type.String,
+    _description: 'UUID for reason for transfer concept',
+    _default: '162720AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
+  locationOfDeathQuestionUuid: {
+    _type: Type.String,
+    _description: 'UUID for location of death question concept',
+    _default: '1541AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
+  locationOfDeathTypesList: {
+    _type: Type.Array,
+    _description: 'List of location of death types',
+    _default: [
+      {
+        concept: '1589AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+        label: 'InPatient',
+      },
+      {
+        concept: '160473AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+        label: 'Outpatient',
+      },
+      {
+        concept: '1601AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+        label: 'Dead on arrival',
+      },
+      {
+        concept: '1536AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+        label: 'Home',
+      },
+      {
+        concept: '1067AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+        label: 'Unknown (Police case)',
+      },
+    ],
+  },
+  deathConfirmationTypes: {
+    _type: Type.Array,
+    _description: 'List of death confirmation types',
+    _default: [
+      {
+        concept: '1065AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+        label: 'Yes',
+      },
+      {
+        concept: '1066AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+        label: 'No',
+      },
+    ],
+  },
+  deathConfirmationQuestionUuid: {
+    _type: Type.String,
+    _description: 'UUID for death confirmation question concept',
+    _default: '165793AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
+  deathNotificationUuid: {
+    _type: Type.String,
+    _description: 'UUID for death notification concept',
+    _default: '162727AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
+  attendingClinicianUuid: {
+    _type: Type.String,
+    _description: 'UUID for attending clinician concept',
+    _default: '160632AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
+  doctorRemarksUuid: {
+    _type: Type.String,
+    _description: 'UUID for doctor remarks concept',
+    _default: '161011AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
+  causeOfDeathUuid: {
+    _type: Type.String,
+    _description: 'UUID for cause of death concept',
+    _default: '160218AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
+  deadBodyPreservationTypeUuid: {
+    _type: Type.Array,
+    _description: 'List of dead body preservation types',
+    _default: [
+      {
+        concept: 'bb78fcee-99c8-4073-9224-69c668917405',
+        label: 'Body embalment',
+      },
+      {
+        concept: '167231AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+        label: 'Cold storage',
+      },
+    ],
+  },
+  deadBodyPreservationQuestionUuid: {
+    _type: Type.String,
+    _description: 'UUID for dead body preservation question concept',
+    _default: 'c67be9a5-f497-4082-af81-11753f65ed4b',
+  },
+  bodyEmbalmmentTypesUuid: {
+    _type: Type.Array,
+    _description: 'List of body embalmment types',
+    _default: [
+      {
+        concept: '166402AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+        label: 'Arterial',
+      },
+      {
+        concept: '160494AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+        label: 'Cavity',
+      },
+      {
+        concept: '151870AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+        label: 'Hypodermic',
+      },
+    ],
+  },
+  autopsyPermissionUuid: {
+    _type: Type.String,
+    _description: 'UUID for autopsy permission concept',
+    _default: '1707AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
 };
 
 export interface BillingConfig {
@@ -151,7 +273,7 @@ export type ConfigObject = {
   morgueAdmissionEncounterTypeUuid: string;
   nextOfKinNameUuid: string;
   nextOfKinRelationshipUuid: string;
-  nextOfKinAddressUuid: string;
+  nextOfKinNationalIdUuid: string;
   nextOfKinPhoneUuid: string;
   visitPaymentMethodAttributeUuid: string;
   policeStatementUuid: string;
@@ -167,4 +289,18 @@ export type ConfigObject = {
   autopsyEncounterFormUuid: string;
   courtOrderCaseNumberUuid: string;
   serialNumberUuid: string;
+  receivingAreaUuid: string;
+  reasonForTransferUuid: string;
+  locationOfDeathQuestionUuid: string;
+  locationOfDeathTypesList: Array<{ concept: string; label: string }>;
+  deathConfirmationTypes: Array<{ concept: string; label: string }>;
+  deathConfirmationQuestionUuid: string;
+  deathNotificationUuid: string;
+  attendingClinicianUuid: string;
+  doctorRemarksUuid: string;
+  causeOfDeathUuid: string;
+  deadBodyPreservationTypeUuid: Array<{ concept: string; label: string }>;
+  deadBodyPreservationQuestionUuid: string;
+  bodyEmbalmmentTypesUuid: Array<{ concept: string; label: string }>;
+  autopsyPermissionUuid: string;
 };

package/src/context/deceased-person-context.tsx

@@ -0,0 +1,33 @@
+import React, { createContext, useContext, ReactNode } from 'react';
+import { type Patient, type MortuaryPatient, type MortuaryLocationResponse, type EnhancedPatient } from '../types';
+
+interface PatientContextValue {
+  mortuaryLocation: MortuaryLocationResponse | null;
+  isLoading: boolean;
+  mutate?: () => void;
+  onAdmit?: (patient: EnhancedPatient | MortuaryPatient | Patient) => void;
+  onPostmortem?: (patientUuid: string, bedInfo?: { bedNumber: string; bedId: number }) => void;
+  onDischarge?: (patientUuid: string, bedId?: number) => void;
+  onSwapCompartment?: (patientUuid: string, bedId?: number) => void;
+  onPrintGatePass?: (patient: EnhancedPatient | Patient, encounterDate?: string) => void;
+  onViewDetails?: (patientUuid: string, bedInfo?: { bedNumber: string; bedId: number }) => void;
+}
+
+const PatientContext = createContext<PatientContextValue | undefined>(undefined);
+
+export const usePatientContext = () => {
+  const context = useContext(PatientContext);
+  if (context === undefined) {
+    throw new Error('usePatientContext must be used within a PatientProvider');
+  }
+  return context;
+};
+
+interface PatientProviderProps {
+  children: ReactNode;
+  value: PatientContextValue;
+}
+
+export const PatientProvider: React.FC<PatientProviderProps> = ({ children, value }) => (
+  <PatientContext.Provider value={value}>{children}</PatientContext.Provider>
+);

package/src/extension/actionButton.component.tsx

@@ -22,7 +22,7 @@ const ActionButton: React.FC<ActionButtonProps> = ({ patientUuid }) => {
     <div className={styles.actionButton}>
       <UserHasAccess privilege="o3 : View Mortuary Dashboard">
         <Button kind="primary" size="sm" renderIcon={Return} onClick={handleNavigateToHomePage}>
-          {t('allocation', 'Allocation View')}
+          {t('backToHome', 'Back to Home')}
         </Button>
       </UserHasAccess>
     </div>

package/src/forms/admit-deceased-person-workspace/admit-deceased-person.resource.ts

@@ -19,9 +19,8 @@ import {
   type VisitTypeResponse,
 } from '../../types';
 import { useCallback, useMemo, useState } from 'react';
-import { deceasedPatientAdmitSchema, dischargeSchema, disposeSchema } from '../../schemas';
+import { deceasedPatientAdmitSchema, dischargeFormSchema, DischargeType } from '../../schemas';
 import useSWRImmutable from 'swr/immutable';
-
 import { z } from 'zod';
 import dayjs from 'dayjs';
 import { customRepProps } from '../../constants';
@@ -118,118 +117,55 @@ export function removeQueuedPatient(
 export const useMortuaryOperation = (location?: string) => {
   const { currentProvider } = useSession();
   const { emrConfiguration, isLoadingEmrConfiguration, errorFetchingEmrConfiguration } = useEmrConfiguration();
-  const {
-    visitPaymentMethodAttributeUuid,
-    tagNumberUuid,
-    obNumberUuid,
-    burialPermitNumberUuid,
-    policeNameUuid,
-    policeIDNumber,
-    dischargeAreaUuid,
-    serialNumberUuid,
-    nextOfKinNameUuid,
-    courtOrderCaseNumberUuid,
-    morgueDischargeEncounterTypeUuid,
-    morgueAdmissionEncounterTypeUuid,
-  } = useConfig<ConfigObject>();
-
-  const createDisposalMortuaryEncounter = useCallback(
-    async (visit: Visit, data: z.infer<typeof disposeSchema>, encounterDateTime: Date) => {
-      const obs = [];
-
-      if (data.courtOrderCaseNumber && data.courtOrderCaseNumber.trim() !== '' && courtOrderCaseNumberUuid) {
-        obs.push({
-          concept: courtOrderCaseNumberUuid,
-          value: data.courtOrderCaseNumber.trim(),
-        });
-      }
+  const config = useConfig<ConfigObject>();
 
-      if (data.serialNumber && data.serialNumber.trim() !== '' && serialNumberUuid) {
-        obs.push({
-          concept: serialNumberUuid,
-          value: data.serialNumber.trim(),
-        });
-      }
+  const createObservation = (conceptUuid: string | undefined, value: any, formatter?: (val: any) => any) => {
+    if (!conceptUuid || !value || (typeof value === 'string' && value.trim() === '')) {
+      return null;
+    }
 
-      const encounterPayload = {
-        encounterDatetime: encounterDateTime.toISOString(),
-        patient: visit?.patient?.uuid,
-        encounterType: morgueDischargeEncounterTypeUuid,
-        location: visit?.location?.uuid,
-        encounterProviders: [
-          {
-            provider: currentProvider?.uuid,
-            encounterRole: emrConfiguration?.clinicianEncounterRole?.uuid,
-          },
-        ],
-        visit: visit?.uuid,
-        ...(obs.length > 0 && { obs }),
-      };
+    const formattedValue = formatter ? formatter(value) : typeof value === 'string' ? value.trim() : value;
+    return { concept: conceptUuid, value: formattedValue };
+  };
 
-      return openmrsFetch<Encounter>(`${restBaseUrl}/encounter`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-        },
-        body: encounterPayload,
-      });
-    },
-    [
-      currentProvider?.uuid,
-      emrConfiguration?.clinicianEncounterRole?.uuid,
-      courtOrderCaseNumberUuid,
-      serialNumberUuid,
-      morgueDischargeEncounterTypeUuid,
-    ],
-  );
+  const getObservationMappings = (formData: z.infer<typeof deceasedPatientAdmitSchema>) => [
+    { uuid: config?.tagNumberUuid, value: formData?.tagNumber, formatter: undefined },
+    { uuid: config?.locationOfDeathQuestionUuid, value: formData?.placeOfDeath, formatter: undefined },
+    { uuid: config?.deathConfirmationQuestionUuid, value: formData?.deathConfirmed, formatter: undefined },
+    { uuid: config?.deathNotificationUuid, value: formData?.deathNotificationNumber, formatter: undefined },
 
-  const createMortuaryAdmissionEncounter = useCallback(
-    async (
-      patientUuid: string,
-      {
-        availableCompartment,
-        dateOfAdmission,
-        insuranceScheme,
-        dischargeArea,
-        obNumber,
-        paymentMethod,
-        period,
-        policeIDNo,
-        policeName,
-        tagNumber,
-        visitType,
-      }: z.infer<typeof deceasedPatientAdmitSchema>,
-    ) => {
-      const obs = [];
+    { uuid: config?.attendingClinicianUuid, value: formData?.attendingClinician, formatter: undefined },
+    { uuid: config?.doctorRemarksUuid, value: formData?.doctorsRemarks, formatter: undefined },
+    { uuid: config?.causeOfDeathUuid, value: formData?.causeOfDeath, formatter: undefined },
+    { uuid: config?.autopsyPermissionUuid, value: formData?.autopsyPermission, formatter: undefined },
+    { uuid: config?.deadBodyPreservationQuestionUuid, value: formData?.deadBodyPreservation, formatter: undefined },
+    { uuid: config?.deadBodyPreservationQuestionUuid, value: formData?.bodyEmbalmentType, formatter: undefined },
 
-      if (tagNumber && tagNumber.trim() !== '' && tagNumberUuid) {
-        obs.push({ concept: tagNumberUuid, value: tagNumber.trim() });
-      }
-      if (obNumber && obNumber.trim() !== '' && obNumberUuid) {
-        obs.push({ concept: obNumberUuid, value: obNumber.trim() });
-      }
-      if (policeName && policeName.trim() !== '' && policeNameUuid) {
-        obs.push({ concept: policeNameUuid, value: policeName.trim() });
-      }
-      if (policeIDNo && policeIDNo.trim() !== '' && policeIDNumber) {
-        obs.push({ concept: policeIDNumber, value: policeIDNo.trim() });
-      }
-      if (dischargeArea && dischargeArea.trim() !== '' && dischargeAreaUuid) {
-        obs.push({ concept: dischargeAreaUuid, value: dischargeArea.trim() });
-      }
+    { uuid: config.obNumberUuid, value: formData.obNumber, formatter: undefined },
+    { uuid: config.policeNameUuid, value: formData.policeName, formatter: undefined },
+    { uuid: config.policeIDNumber, value: formData.policeIDNo, formatter: undefined },
+  ];
+
+  const createMortuaryAdmissionEncounter = useCallback(
+    async (patientUuid: string, formData: z.infer<typeof deceasedPatientAdmitSchema>) => {
+      const observationMappings = getObservationMappings(formData);
+      const obs = observationMappings
+        .map(({ uuid, value, formatter }) => createObservation(uuid, value, formatter))
+        .filter(Boolean);
 
       const visitAttributes = [];
       const encounterPayload = {
         visit: {
           patient: patientUuid,
-          startDatetime: dayjs(dateOfAdmission).toISOString(),
-          visitType: visitType,
+          startDatetime: dayjs(formData.dateOfAdmission).toISOString(),
+          visitType: formData.visitType,
           location: location,
           ...(visitAttributes.length > 0 && { attributes: visitAttributes }),
         },
         patient: patientUuid,
-        encounterType: morgueAdmissionEncounterTypeUuid,
+        encounterType: config.morgueAdmissionEncounterTypeUuid,
         location,
+        encounterDatetime: dayjs(formData.dateOfAdmission).toISOString(),
         encounterProviders: [
           {
             provider: currentProvider?.uuid,
@@ -247,32 +183,43 @@ export const useMortuaryOperation = (location?: string) => {
         body: encounterPayload,
       });
     },
-    [
-      currentProvider?.uuid,
-      dischargeAreaUuid,
-      emrConfiguration?.admissionEncounterType?.uuid,
-      emrConfiguration?.clinicianEncounterRole?.uuid,
-      location,
-      obNumberUuid,
-      policeIDNumber,
-      policeNameUuid,
-      tagNumberUuid,
-      morgueAdmissionEncounterTypeUuid,
-    ],
+    [currentProvider?.uuid, emrConfiguration?.clinicianEncounterRole?.uuid, location, config],
   );
 
-  const createDischargeMortuaryEncounter = useCallback(
-    async (visit: Visit, data: z.infer<typeof dischargeSchema>, encounterDateTime: Date) => {
-      const obs = [];
+  const getDischargeObservationMappings = (data: z.infer<typeof dischargeFormSchema>) => {
+    const baseFields = [
+      { uuid: config.burialPermitNumberUuid, value: data.burialPermitNumber },
+      { uuid: config.dischargeAreaUuid, value: data.dischargeArea },
+    ];
+
+    const transferFields =
+      data.dischargeType === 'transfer'
+        ? [
+            { uuid: config.receivingAreaUuid, value: data.receivingArea },
+            { uuid: config.reasonForTransferUuid, value: data.reasonForTransfer },
+          ]
+        : [];
+
+    const disposeFields =
+      data.dischargeType === 'dispose'
+        ? [
+            { uuid: config.serialNumberUuid, value: data.serialNumber },
+            { uuid: config.courtOrderCaseNumberUuid, value: data.courtOrderCaseNumber },
+          ]
+        : [];
+
+    return [...baseFields, ...transferFields, ...disposeFields];
+  };
 
-      if (data.burialPermitNumber && data.burialPermitNumber.trim() !== '' && burialPermitNumberUuid) {
-        obs.push({ concept: burialPermitNumberUuid, value: data.burialPermitNumber.trim() });
-      }
+  const createDischargeEncounter = useCallback(
+    async (visit: Visit, data: z.infer<typeof dischargeFormSchema>, encounterDateTime: Date) => {
+      const observationMappings = getDischargeObservationMappings(data);
+      const obs = observationMappings.map(({ uuid, value }) => createObservation(uuid, value)).filter(Boolean);
 
       const encounterPayload = {
         encounterDatetime: encounterDateTime.toISOString(),
         patient: visit?.patient?.uuid,
-        encounterType: morgueDischargeEncounterTypeUuid,
+        encounterType: config.morgueDischargeEncounterTypeUuid,
         location: visit?.location?.uuid,
         encounterProviders: [
           {
@@ -292,13 +239,9 @@ export const useMortuaryOperation = (location?: string) => {
         body: encounterPayload,
       });
     },
-    [
-      burialPermitNumberUuid,
-      currentProvider?.uuid,
-      emrConfiguration?.clinicianEncounterRole?.uuid,
-      morgueDischargeEncounterTypeUuid,
-    ],
+    [config, currentProvider?.uuid, emrConfiguration?.clinicianEncounterRole?.uuid],
   );
+
   const assignDeceasedToCompartment = useCallback(
     async (patientUuid: string, bedId: number, encounterUuid: string) =>
       openmrsFetch(`${restBaseUrl}/beds/${bedId}`, {
@@ -318,10 +261,8 @@ export const useMortuaryOperation = (location?: string) => {
     async (patientUuid: string, data: z.infer<typeof deceasedPatientAdmitSchema>) => {
       try {
         const admissionEncounter = await createMortuaryAdmissionEncounter(patientUuid, data);
-
-        const encounterUuid = admissionEncounter?.data?.uuid || admissionEncounter?.data?.uuid;
+        const encounterUuid = admissionEncounter?.data?.uuid;
         const compartment = await assignDeceasedToCompartment(patientUuid, data.availableCompartment, encounterUuid);
-
         return { admissionEncounter, compartment };
       } catch (error) {
         throw error;
@@ -341,7 +282,6 @@ export const useMortuaryOperation = (location?: string) => {
   const endCurrentVisit = useCallback(
     async (currentVisit: Visit, queueEntry: MappedVisitQueueEntry, stopDateTime: Date) => {
       const abortController = new AbortController();
-
       const response = await updateVisit(
         currentVisit.uuid,
         {
@@ -363,50 +303,30 @@ export const useMortuaryOperation = (location?: string) => {
   );
 
   const dischargeBody = useCallback(
-    async (visit: Visit, queueEntry: MappedVisitQueueEntry, bedId: number, data: z.infer<typeof dischargeSchema>) => {
+    async (
+      visit: Visit,
+      queueEntry: MappedVisitQueueEntry,
+      bedId: number,
+      data: z.infer<typeof dischargeFormSchema>,
+    ) => {
       try {
-        const dischargeDateTime = parseDischargeDateTime({
-          ...data,
-          dateOfDischarge: data.dateOfDischarge ?? new Date(),
-        });
-
-        const dischargeEncounter = await createDischargeMortuaryEncounter(visit, data, dischargeDateTime);
-
+        const dischargeDateTime =
+          data.dischargeType === 'dispose'
+            ? new Date()
+            : parseDischargeDateTime({
+                ...data,
+                dateOfDischarge: data.dateOfDischarge ?? new Date(),
+              });
+
+        const dischargeEncounter = await createDischargeEncounter(visit, data, dischargeDateTime);
         const compartment = await removeDeceasedFromCompartment(visit?.patient?.uuid, bedId);
 
-        const visitStopTime = new Date(dischargeDateTime.getTime() + 60000); // 1 minute after discharge
-
-        await endCurrentVisit(visit, queueEntry, visitStopTime);
-
         return { dischargeEncounter, compartment };
       } catch (error) {
         throw error;
       }
     },
-    [createDischargeMortuaryEncounter, endCurrentVisit, removeDeceasedFromCompartment, parseDischargeDateTime],
-  );
-  const disposeBody = useCallback(
-    async (visit: Visit, queueEntry: MappedVisitQueueEntry, bedId: number, data: z.infer<typeof disposeSchema>) => {
-      try {
-        const disposalDateTime = parseDischargeDateTime({
-          ...data,
-          dateOfDischarge: data.dateOfDischarge ?? new Date(),
-        });
-
-        const disposeEncounter = await createDisposalMortuaryEncounter(visit, data, disposalDateTime);
-
-        const compartment = await removeDeceasedFromCompartment(visit?.patient?.uuid, bedId);
-
-        const visitStopTime = new Date(disposalDateTime.getTime() + 60000);
-
-        await endCurrentVisit(visit, queueEntry, visitStopTime);
-
-        return { disposeEncounter, compartment };
-      } catch (error) {
-        throw error;
-      }
-    },
-    [createDisposalMortuaryEncounter, endCurrentVisit, removeDeceasedFromCompartment, parseDischargeDateTime],
+    [createDischargeEncounter, endCurrentVisit, removeDeceasedFromCompartment, parseDischargeDateTime],
   );
 
   const createEncounterForCompartmentSwap = useCallback(
@@ -441,8 +361,6 @@ export const useMortuaryOperation = (location?: string) => {
 
   return {
     admitBody,
-    disposeBody,
-    createDisposalMortuaryEncounter,
     createEncounterForCompartmentSwap,
     assignDeceasedToCompartment,
     removeDeceasedFromCompartment,

package/src/forms/admit-deceased-person-workspace/admit-deceased-person.scss

@@ -141,3 +141,17 @@
 .sectionField {
   padding-top: layout.$spacing-03;
 }
+.radioButton {
+  padding: 0;
+  margin-top: layout.$spacing-03;
+}
+
+.radioButton:last-child {
+  margin-bottom: 0;
+}
+
+.supportingDocuments {
+  margin-top: layout.$spacing-05;
+  margin-bottom: layout.$spacing-05;
+  border-bottom: 1px solid colors.$gray-20;
+}