@kenyaemr/esm-morgue-app 5.4.2-pre.2294 → 5.4.2-pre.2301

package/src/forms/dispose-deceased-person-workspace/dispose-deceased-person.workspace.tsx

@@ -25,7 +25,7 @@ import {
   useLayoutType,
   useVisit,
 } from '@openmrs/esm-framework';
-import React, { useCallback, useEffect } from 'react';
+import React, { useCallback, useEffect, useState } from 'react';
 import { Controller, useForm } from 'react-hook-form';
 import { useTranslation } from 'react-i18next';
 import { mutate as mutateSWR } from 'swr';
@@ -47,46 +47,66 @@ import { useMortuaryOperation } from '../admit-deceased-person-workspace/admit-d
 interface DisposeFormProps {
   closeWorkspace: () => void;
   patientUuid: string;
-  personUuid: string;
   bedId: number;
   mutate: () => void;
 }
 
 type DisposeFormValues = z.infer<typeof disposeSchema>;
 
-const DisposeForm: React.FC<DisposeFormProps> = ({ closeWorkspace, patientUuid, bedId, personUuid, mutate }) => {
+const DisposeForm: React.FC<DisposeFormProps> = ({ closeWorkspace, patientUuid, bedId, mutate }) => {
   const { t } = useTranslation();
   const isTablet = useLayoutType() === 'tablet';
+  const [submissionError, setSubmissionError] = useState<string | null>(null);
+
   const { activeVisit, currentVisitIsRetrospective } = useVisit(patientUuid);
   const { queueEntry } = useVisitQueueEntry(patientUuid, activeVisit?.uuid);
+
   const { disposeBody, isLoadingEmrConfiguration } = useMortuaryOperation();
-  const { createOrUpdatePersonAttribute, personAttributes } = usePersonAttributes(personUuid);
-  const { mutateAll, mutateAwaitingQueuePatients } = useAwaitingQueuePatients();
+
+  const {
+    createOrUpdatePersonAttribute,
+    personAttributes,
+    isLoading: isLoadingAttributes,
+  } = usePersonAttributes(patientUuid);
+
   const { isDischargeBlocked, blockingMessage, isLoadingBills } = useBlockDischargeWithPendingBills({
     patientUuid,
+    actionType: 'dispose',
   });
-  const { time: defaultTime, period: defaultPeriod } = getCurrentTime();
 
   const { nextOfKinNameUuid, nextOfKinRelationshipUuid, nextOfKinPhoneUuid, nextOfKinAddressUuid } =
     useConfig<ConfigObject>();
 
+  const { time: defaultTime, period: defaultPeriod } = getCurrentTime();
+
   const getAttributeValue = useCallback(
     (attributeTypeUuid: string) => {
-      if (!personAttributes) {
+      if (!personAttributes || !Array.isArray(personAttributes)) {
         return '';
       }
-      const attributes = Array.isArray(personAttributes) ? personAttributes : [];
-      const attribute = attributes.find((attr) => attr.attributeType.uuid === attributeTypeUuid);
+      const attribute = personAttributes.find((attr) => attr.attributeType.uuid === attributeTypeUuid);
       return attribute ? attribute.value : '';
     },
     [personAttributes],
   );
 
+  const getExistingAttributeUuid = useCallback(
+    (attributeTypeUuid: string) => {
+      if (!personAttributes || !Array.isArray(personAttributes)) {
+        return null;
+      }
+      const attribute = personAttributes.find((attr) => attr.attributeType.uuid === attributeTypeUuid);
+      return attribute ? attribute.uuid : null;
+    },
+    [personAttributes],
+  );
+
   const {
     control,
     setValue,
     handleSubmit,
     formState: { errors, isDirty, isSubmitting },
+    watch,
   } = useForm<DisposeFormValues>({
     resolver: zodResolver(disposeSchema),
     defaultValues: {
@@ -104,22 +124,32 @@ const DisposeForm: React.FC<DisposeFormProps> = ({ closeWorkspace, patientUuid,
 
   useEffect(() => {
     if (Array.isArray(personAttributes) && personAttributes.length > 0) {
-      setValue('nextOfKinNames', getAttributeValue(nextOfKinNameUuid));
-      setValue('relationshipType', getAttributeValue(nextOfKinRelationshipUuid));
-      setValue('nextOfKinContact', getAttributeValue(nextOfKinPhoneUuid));
-      setValue('nextOfKinAddress', getAttributeValue(nextOfKinAddressUuid));
+      const initialValues = {
+        nextOfKinNames: getAttributeValue(nextOfKinNameUuid),
+        relationshipType: getAttributeValue(nextOfKinRelationshipUuid),
+        nextOfKinContact: getAttributeValue(nextOfKinPhoneUuid),
+        nextOfKinAddress: getAttributeValue(nextOfKinAddressUuid),
+      };
+
+      Object.entries(initialValues).forEach(([field, value]) => {
+        if (value !== undefined && value !== null && value !== '') {
+          setValue(field as keyof DisposeFormValues, value);
+        }
+      });
     }
   }, [
     personAttributes,
+    setValue,
     getAttributeValue,
     nextOfKinNameUuid,
     nextOfKinRelationshipUuid,
     nextOfKinPhoneUuid,
     nextOfKinAddressUuid,
-    setValue,
   ]);
 
   const onSubmit = async (data: DisposeFormValues) => {
+    setSubmissionError(null);
+
     if (currentVisitIsRetrospective) {
       setCurrentVisit(null, null);
       closeWorkspace();
@@ -127,35 +157,63 @@ const DisposeForm: React.FC<DisposeFormProps> = ({ closeWorkspace, patientUuid,
     }
 
     try {
-      const nextOfKinAttributes = [
-        { attributeType: nextOfKinNameUuid, value: data.nextOfKinNames },
-        { attributeType: nextOfKinRelationshipUuid, value: data.relationshipType },
-        { attributeType: nextOfKinPhoneUuid, value: data.nextOfKinContact },
-        { attributeType: nextOfKinAddressUuid, value: data.nextOfKinAddress },
-      ];
+      await disposeBody(activeVisit, queueEntry, bedId, data);
+
+      const attributeUpdates = [
+        {
+          uuid: nextOfKinNameUuid,
+          value: data.nextOfKinNames,
+          existingUuid: getExistingAttributeUuid(nextOfKinNameUuid),
+        },
+        {
+          uuid: nextOfKinRelationshipUuid,
+          value: data.relationshipType,
+          existingUuid: getExistingAttributeUuid(nextOfKinRelationshipUuid),
+        },
+        {
+          uuid: nextOfKinPhoneUuid,
+          value: data.nextOfKinContact,
+          existingUuid: getExistingAttributeUuid(nextOfKinPhoneUuid),
+        },
+        {
+          uuid: nextOfKinAddressUuid,
+          value: data.nextOfKinAddress,
+          existingUuid: getExistingAttributeUuid(nextOfKinAddressUuid),
+        },
+      ].filter((attr) => attr.value !== undefined && attr.value !== null && attr.value !== '');
 
       const patientInfo: PatientInfo = {
         uuid: activeVisit.patient.uuid,
-        attributes: (activeVisit?.patient?.person?.attributes || []).map((attr) => ({
-          uuid: attr.uuid,
-          display: attr.display || '',
-        })),
+        attributes: personAttributes || [],
       };
 
-      for (const attribute of nextOfKinAttributes) {
+      for (const attr of attributeUpdates) {
         try {
-          await createOrUpdatePersonAttribute(patientUuid, attribute, patientInfo);
-        } catch (attributeError) {
+          const attributeData: any = {
+            attributeType: attr.uuid,
+            value: attr.value,
+          };
+
+          if (attr.existingUuid) {
+            attributeData.uuid = attr.existingUuid;
+          }
+
+          await createOrUpdatePersonAttribute(patientUuid, attributeData, patientInfo);
+        } catch (error) {
           showSnackbar({
-            title: t('errorDisposingPatient', 'Error disposing patient'),
-            subtitle: attributeError?.message || t('unknownError', 'Unknown error occurred'),
+            title: t('errorUpdatingAttribute', 'Error Updating Attribute'),
+            subtitle: t('errorUpdatingAttributeDescription', 'An error occurred while updating the attribute'),
             kind: 'error',
             isLowContrast: true,
           });
         }
       }
 
-      await disposeBody(activeVisit, queueEntry, bedId, data);
+      await Promise.all([
+        mutateSWR((key) => typeof key === 'string' && key.startsWith(`${restBaseUrl}/visit`)),
+        mutateSWR((key) => typeof key === 'string' && key.startsWith(`${restBaseUrl}/patient`)),
+        mutateSWR((key) => typeof key === 'string' && key.startsWith(`${fhirBaseUrl}/Encounter`)),
+      ]);
 
       showSnackbar({
         title: t('disposedDeceasedPatient', 'Deceased patient disposed'),
@@ -164,41 +222,66 @@ const DisposeForm: React.FC<DisposeFormProps> = ({ closeWorkspace, patientUuid,
         isLowContrast: true,
       });
 
-      mutateSWR((key) => typeof key === 'string' && key.startsWith(`${restBaseUrl}/visit`));
-      mutateSWR((key) => typeof key === 'string' && key.startsWith(`${restBaseUrl}/patient`));
-      mutateSWR((key) => typeof key === 'string' && key.startsWith(`${fhirBaseUrl}/Encounter`));
-      mutateAwaitingQueuePatients();
-      mutateAll();
       mutate();
       closeWorkspace();
     } catch (error) {
+      let errorMessage = t('disposeUnknownError', 'An unknown error occurred');
+      if (error?.message) {
+        errorMessage = error.message;
+      } else if (error?.responseBody?.error?.message) {
+        errorMessage = error.responseBody.error.message.replace(/\[|\]/g, '');
+      } else if (error?.responseBody?.error?.globalErrors) {
+        errorMessage = error.responseBody.error.globalErrors[0]?.message || errorMessage;
+      }
+
+      setSubmissionError(errorMessage);
       showSnackbar({
-        title: t('errorDisposingPatient', 'Error disposing patient'),
-        subtitle: error?.message || t('unknownError', 'Unknown error occurred'),
+        title: t('disposedError', 'Dispose Error'),
+        subtitle: errorMessage,
         kind: 'error',
         isLowContrast: true,
       });
     }
   };
 
-  if (isLoadingEmrConfiguration || !personAttributes || !activeVisit) {
-    return <InlineLoading status="active" iconDescription="Loading" description="Loading ..." />;
+  if (isLoadingEmrConfiguration || isLoadingAttributes || !activeVisit) {
+    return <InlineLoading status="active" iconDescription="Loading" description={t('loading', 'Loading...')} />;
   }
 
   return (
     <Form onSubmit={handleSubmit(onSubmit)} className={styles.form}>
       <div className={styles.formContainer}>
+        {isLoadingBills && (
+          <InlineLoading
+            status="active"
+            iconDescription="Loading"
+            description={t('loadingBills', 'Loading bills...')}
+          />
+        )}
+
+        {isDischargeBlocked && (
+          <InlineNotification
+            kind="warning"
+            title={t('warningMsg', 'Warning')}
+            subtitle={blockingMessage}
+            lowContrast={true}
+            className={styles.blockingNotification}
+          />
+        )}
+
+        {submissionError && (
+          <InlineNotification
+            kind="error"
+            title={t('error', 'Error')}
+            subtitle={submissionError}
+            lowContrast={true}
+            className={styles.errorNotification}
+          />
+        )}
+
         <Stack gap={3}>
           <DeceasedInfo patientUuid={patientUuid} />
-          {isDischargeBlocked && (
-            <InlineNotification
-              kind="error"
-              title={t('disposeBlocked', 'Dispose Blocked')}
-              subtitle={blockingMessage}
-              lowContrast={true}
-              className={styles.blockingNotification}
-            />
-          )}
+
           <ResponsiveWrapper>
             <div className={styles.dateTimePickerContainer}>
               <Column>
@@ -377,6 +460,7 @@ const DisposeForm: React.FC<DisposeFormProps> = ({ closeWorkspace, patientUuid,
               />
             </Column>
           </ResponsiveWrapper>
+
           <ResponsiveWrapper>
             <Column>
               <ExtensionSlot
@@ -390,6 +474,7 @@ const DisposeForm: React.FC<DisposeFormProps> = ({ closeWorkspace, patientUuid,
           </ResponsiveWrapper>
         </Stack>
       </div>
+
       <ButtonSet
         className={classNames({
           [styles.tablet]: isTablet,

package/src/home/home.component.tsx

@@ -18,7 +18,7 @@ const HomeViewComponent: React.FC = () => {
     admissionLocation,
     isLoading: isLoadingAdmission,
     error: admissionError,
-    mutate,
+    mutate: mutateAdmissionLocation,
   } = useMortuaryAdmissionLocation(selectedLocation);
 
   const {
@@ -34,6 +34,11 @@ const HomeViewComponent: React.FC = () => {
     mutateAll,
   } = useAwaitingQueuePatients(admissionLocation);
 
+  const mutateAllData = React.useCallback(() => {
+    mutateAdmissionLocation();
+    mutateAll();
+  }, [mutateAdmissionLocation, mutateAll]);
+
   const locationItems = React.useMemo(() => {
     return locations.map((location) => ({
       id: location.ward.uuid,
@@ -76,7 +81,7 @@ const HomeViewComponent: React.FC = () => {
         locationError={locationError}
         admissionError={admissionError}
         onLocationChange={handleLocationChange}
-        mutate={mutate}
+        mutate={mutateAllData}
         dischargedPatients={dischargedPatients}
         isLoadingDischarge={isLoadingDischarge}
       />

package/src/home/home.resource.ts

@@ -24,7 +24,7 @@ interface MortuaryApiResponse {
 
 export const useAwaitingQueuePatients = (admissionLocation?: MortuaryLocationResponse) => {
   const { morgueDischargeEncounterTypeUuid } = useConfig<ConfigObject>();
-  const [currPageSize, setCurrPageSize] = useState(10);
+  const [currPageSize, setCurrPageSize] = useState(100);
 
   const customRepresentation =
     'custom:(uuid,display,identifiers:(identifier,uuid,preferred,location:(uuid,name)),person:(uuid,display,gender,birthdate,dead,age,deathDate,causeOfDeath:(uuid,display),preferredAddress:(uuid,stateProvince,countyDistrict,address4)))';

package/src/switcher/content-switcher.component.tsx

@@ -153,7 +153,6 @@ const CustomContentSwitcher: React.FC<CustomContentSwitcherProps> = ({
     },
     [
       selectedView,
-      t,
       awaitingQueueDeceasedPatients,
       isLoading,
       admissionLocation,

package/src/types/index.ts

@@ -358,10 +358,7 @@ export interface PatientInfo {
     };
   };
   uuid: string;
-  attributes: {
-    uuid: string;
-    display: string;
-  }[];
+  attributes: Attribute[];
 }
 
 export interface UseVisitQueueEntries {

package/src/utils/utils.ts

@@ -87,42 +87,26 @@ export function parseDisplayText(displayText: string): { name: string; openmrsId
   }
 }
 
-export const patientInfoSchema = z.object({
-  dateOfAdmission: z
-    .date({ coerce: true })
-    .refine((date) => !!date, 'Date of admission is required')
-    .refine((date) => date <= new Date(), 'Date of admission cannot be in the future'),
-  timeOfDeath: z.string().nonempty('Time of death is required'),
-  period: z
-    .string()
-    .nonempty('AM/PM is required')
-    .regex(/^(AM|PM)$/i, 'Invalid period'),
-  tagNumber: z.string().nonempty('Tag number is required'),
-  obNumber: z.string().optional(),
-  policeName: z.string().optional(),
-  policeIDNo: z.string().optional(),
-  dischargeArea: z.string().optional(),
-  visitType: z.string().uuid('invalid visit type'),
-  availableCompartment: z.number({ coerce: true }),
-  services: z.array(z.string().uuid('invalid service')).nonempty('Must select one service'),
-  paymentMethod: z.string().uuid('invalid payment method'),
-  insuranceScheme: z.string().optional(),
-  policyNumber: z.string().optional(),
-});
-
-export const dischargeSchema = z.object({
-  dateOfDischarge: z.date({ coerce: true }).refine((date) => !!date, 'Date of discharge is required'),
-  timeOfDischarge: z.string().nonempty('Time of discharge is required'),
-  period: z
-    .string()
-    .nonempty('AM/PM is required')
-    .regex(/^(AM|PM)$/i, 'Invalid period'),
-  burialPermitNumber: z.string().nonempty('Burial Permit Number is required'),
-  nextOfKinNames: z.string().nonempty('Next of kin names is required'),
-  relationshipType: z.string().nonempty('Next of kin relationship is required'),
-  nextOfKinAddress: z.string().nonempty('Next of kin address is required'),
-  nextOfKinContact: z
-    .string()
-    .regex(/^\d{10}$/, 'Phone number must be exactly 10 digits')
-    .nonempty('Next of kin phone number is required'),
-});
+export const parseDischargeDateTime = (data: {
+  dateOfDischarge: string | Date;
+  timeOfDischarge?: string;
+  period?: string;
+}) => {
+  const dischargeDateTime =
+    typeof data.dateOfDischarge === 'string' ? new Date(data.dateOfDischarge) : new Date(data.dateOfDischarge);
+
+  if (data.timeOfDischarge && data.period) {
+    const [hours, minutes] = data.timeOfDischarge.split(':');
+    let hour = parseInt(hours, 10);
+
+    if (data.period === 'PM' && hour !== 12) {
+      hour += 12;
+    } else if (data.period === 'AM' && hour === 12) {
+      hour = 0;
+    }
+
+    dischargeDateTime.setHours(hour, parseInt(minutes, 10), 0, 0);
+  }
+
+  return dischargeDateTime;
+};