@kenyaemr/esm-morgue-app 5.4.2-pre.2279 → 5.4.2-pre.2288

package/src/bed-layout/awaiting/awaiting-bed-layout.component.tsx

@@ -0,0 +1,86 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { InlineLoading, SkeletonText } from '@carbon/react';
+import styles from '../bed-layout.scss';
+import BedCard from '../../bed/bed.component';
+import { MortuaryPatient, MortuaryLocationResponse } from '../../types';
+import { useAwaitingPatients } from '../../home/home.resource';
+import { launchWorkspace } from '@openmrs/esm-framework';
+import { EmptyState } from '@openmrs/esm-patient-common-lib/src';
+
+interface BedLayoutProps {
+  awaitingQueueDeceasedPatients: MortuaryPatient[];
+  mortuaryLocation: MortuaryLocationResponse;
+  isLoading: boolean;
+  mutated?: () => void;
+}
+
+const AwaitingBedLayout: React.FC<BedLayoutProps> = ({
+  awaitingQueueDeceasedPatients,
+  mortuaryLocation,
+  isLoading,
+  mutated,
+}) => {
+  const { t } = useTranslation();
+
+  const trulyAwaitingPatients = useAwaitingPatients(awaitingQueueDeceasedPatients);
+
+  if (isLoading) {
+    return (
+      <div className={styles.emptyState}>
+        <SkeletonText />
+        <InlineLoading description={t('loadingPatients', 'Loading patients...')} />
+      </div>
+    );
+  }
+
+  if (trulyAwaitingPatients.length === 0) {
+    return (
+      <div className={styles.emptyState}>
+        <EmptyState
+          headerTitle={t('noAwaitingPatients', 'No awaiting patients found')}
+          displayText={t('noAwaitingPatientsDescription', 'There are currently no awaiting patients to display.')}
+        />
+      </div>
+    );
+  }
+
+  const handleAdmit = (patientData: MortuaryPatient) => {
+    launchWorkspace('admit-deceased-person-form', {
+      workspaceTitle: t('admissionForm', 'Admission form'),
+      patientData,
+      mortuaryLocation,
+      mutated,
+    });
+  };
+
+  return (
+    <div className={styles.bedLayoutWrapper}>
+      <div className={styles.bedLayoutContainer}>
+        {trulyAwaitingPatients.map((mortuaryPatient) => {
+          const patientUuid = mortuaryPatient?.person?.person?.uuid;
+          const patientName = mortuaryPatient?.person?.person?.display;
+          const gender = mortuaryPatient?.person?.person?.gender;
+          const age = mortuaryPatient?.person?.person?.age;
+          const causeOfDeath = mortuaryPatient?.person?.person?.causeOfDeath?.display;
+          const dateOfDeath = mortuaryPatient?.person?.person?.deathDate;
+
+          return (
+            <BedCard
+              key={patientUuid}
+              patientName={patientName}
+              gender={gender}
+              age={age}
+              causeOfDeath={causeOfDeath}
+              dateOfDeath={dateOfDeath}
+              patientUuid={patientUuid}
+              onAdmit={() => handleAdmit(mortuaryPatient)}
+            />
+          );
+        })}
+      </div>
+    </div>
+  );
+};
+
+export default AwaitingBedLayout;

package/src/bed-layout/bed-layout.resource.ts

@@ -0,0 +1,72 @@
+import { FetchResponse, openmrsFetch, restBaseUrl, useConfig } from '@openmrs/esm-framework';
+import { useMemo } from 'react';
+import useSWR from 'swr';
+import { type MortuaryLocationResponse, type AdmissionLocationResponse, type Bed, type MappedBedData } from '../types';
+import { ConfigObject } from '../config-schema';
+
+export const useLocation = () => {
+  const { mortuaryLocationTagUuid } = useConfig<ConfigObject>();
+  const url = `${restBaseUrl}/admissionLocation?v=full`;
+  const { isLoading, error, data, mutate } = useSWR<FetchResponse<AdmissionLocationResponse>>(url, openmrsFetch);
+
+  const mortuaryLocations = useMemo(() => {
+    if (!data?.data?.results || !mortuaryLocationTagUuid) {
+      return [];
+    }
+
+    return data.data.results.filter((location) =>
+      location.ward.tags.some((tag) => tag.uuid === mortuaryLocationTagUuid),
+    );
+  }, [data?.data?.results, mortuaryLocationTagUuid]);
+
+  return {
+    locations: mortuaryLocations,
+    isLoading,
+    error,
+    mutate,
+  };
+};
+
+export const useBedsForLocation = (locationUuid: string) => {
+  const apiUrl = `${restBaseUrl}/bed?locationUuid=${locationUuid}&v=full`;
+
+  const { data, isLoading, error, mutate, isValidating } = useSWR<{ data: { results: Array<Bed> } }, Error>(
+    locationUuid ? apiUrl : null,
+    openmrsFetch,
+  );
+
+  const mappedBedData: MappedBedData = (data?.data?.results ?? []).map((bed) => ({
+    id: bed.id,
+    type: bed.bedType?.displayName,
+    number: bed.bedNumber,
+    status: bed.status,
+    uuid: bed.uuid,
+  }));
+
+  const results = useMemo(
+    () => ({
+      bedsData: mappedBedData,
+      errorLoadingBeds: error,
+      isLoadingBeds: isLoading,
+      mutate,
+      isValidating,
+    }),
+    [mappedBedData, isLoading, error, mutate, isValidating],
+  );
+
+  return results;
+};
+
+export function useMortuaryAdmissionLocation(locationUuid: string) {
+  const customRepresentation =
+    'custom:(ward,totalBeds,occupiedBeds,bedLayouts:(rowNumber,columnNumber,bedNumber,bedType,bedId,bedUuid,status,location,patients:(person:full,identifiers,uuid)))';
+
+  const url = locationUuid ? `${restBaseUrl}/admissionLocation/${locationUuid}?v=${customRepresentation}` : null;
+
+  const { data, ...rest } = useSWR<FetchResponse<MortuaryLocationResponse>, Error>(url, openmrsFetch);
+
+  return {
+    admissionLocation: data?.data,
+    ...rest,
+  };
+}

package/src/bed-layout/bed-layout.scss

@@ -0,0 +1,55 @@
+@use '@carbon/colors';
+@use '@carbon/layout';
+
+.bedLayoutContainer {
+  background-color: colors.$white-0;
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  justify-content: space-between;
+  flex: 1;
+  overflow-y: auto;
+  overflow-x: hidden;
+  padding: layout.$spacing-02;
+  max-height: calc(100vh - 200px);
+  gap: 1rem;
+  &::-webkit-scrollbar {
+    width: 8px;
+  }
+
+  &::-webkit-scrollbar-track {
+    background: colors.$white-0;
+    border-radius: 4px;
+  }
+
+  &::-webkit-scrollbar-thumb {
+    background: colors.$gray-30;
+    border-radius: 4px;
+
+    &:hover {
+      background: colors.$gray-40;
+    }
+  }
+}
+
+.bedLayoutWrapper {
+  height: 100%;
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+}
+
+.loadingContainer {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  height: 200px;
+}
+
+.emptyState {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  height: 200px;
+  color: colors.$gray-60;
+  font-style: italic;
+}

package/src/bed-layout/discharged/discharged-bed-layout.component.tsx

@@ -0,0 +1,109 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { InlineLoading } from '@carbon/react';
+import { launchWorkspace, useConfig } from '@openmrs/esm-framework';
+import styles from '../bed-layout.scss';
+import { type MortuaryLocationResponse } from '../../types';
+import { ConfigObject } from '../../config-schema';
+import { mutate as mutateSWR } from 'swr';
+import usePatients, { useMortuaryDischargeEncounter } from './discharged-bed-layout.resource';
+import BedCard from '../../bed/bed.component';
+
+interface BedLayoutProps {
+  AdmittedDeceasedPatient: MortuaryLocationResponse | null;
+  isLoading: boolean;
+  onPrintGatePass?: (patientUuid: string) => void;
+  onPrintPostmortem?: (patientUuid: string) => void;
+  mutate?: () => void;
+}
+
+const DischargedBedLayout: React.FC<BedLayoutProps> = ({
+  AdmittedDeceasedPatient,
+  isLoading,
+  onPrintGatePass,
+  onPrintPostmortem,
+  mutate,
+}) => {
+  const { t } = useTranslation();
+  const { morgueDischargeEncounterTypeUuid } = useConfig<ConfigObject>();
+
+  const {
+    dischargedPatientUuids,
+    isLoading: encountersLoading,
+    error: encountersError,
+  } = useMortuaryDischargeEncounter(morgueDischargeEncounterTypeUuid, AdmittedDeceasedPatient);
+
+  const {
+    patients: dischargedPatients,
+    isLoading: patientsLoading,
+    error: patientsError,
+  } = usePatients(dischargedPatientUuids || []);
+
+  const handlePrintGatePass = (patientUuid: string) => {
+    if (onPrintGatePass) {
+      onPrintGatePass(patientUuid);
+    }
+  };
+
+  const handlePrintPostmortem = (patientUuid: string) => {
+    if (onPrintPostmortem) {
+      onPrintPostmortem(patientUuid);
+    }
+  };
+
+  if (isLoading || encountersLoading || patientsLoading) {
+    return (
+      <div className={styles.loadingContainer}>
+        <InlineLoading description={t('loadingPatients', 'Loading patients...')} />
+      </div>
+    );
+  }
+
+  if (encountersError || patientsError) {
+    return (
+      <div className={styles.emptyState}>
+        <p>{t('errorLoadingPatients', 'Error loading discharged patients')}</p>
+      </div>
+    );
+  }
+
+  if (!dischargedPatients || dischargedPatients.length === 0) {
+    return (
+      <div className={styles.emptyState}>
+        <p>{t('noDischargedPatients', 'No discharged patients found')}</p>
+      </div>
+    );
+  }
+
+  return (
+    <div className={styles.bedLayoutWrapper}>
+      <div className={styles.bedLayoutContainer}>
+        {dischargedPatients.map((patient) => {
+          const patientUuid = patient?.uuid;
+          const patientName = patient?.person?.display;
+          const gender = patient?.person?.gender;
+          const age = patient?.person?.age;
+          const causeOfDeath = patient?.person?.causeOfDeath?.display;
+          const dateOfDeath = patient?.person?.deathDate;
+
+          return (
+            <BedCard
+              key={patientUuid}
+              patientName={patientName}
+              gender={gender}
+              age={age}
+              causeOfDeath={causeOfDeath}
+              dateOfDeath={dateOfDeath}
+              patientUuid={patientUuid}
+              onPrintGatePass={() => handlePrintGatePass(patientUuid)}
+              onPrintPostmortem={() => handlePrintPostmortem(patientUuid)}
+              isDischarged={true}
+            />
+          );
+        })}
+      </div>
+    </div>
+  );
+};
+
+export default DischargedBedLayout;

package/src/bed-layout/discharged/discharged-bed-layout.resource.ts

@@ -0,0 +1,99 @@
+import {
+  FetchResponse,
+  fhirBaseUrl,
+  openmrsFetch,
+  restBaseUrl,
+  useFhirFetchAll,
+  useFhirPagination,
+} from '@openmrs/esm-framework';
+import useSWR from 'swr';
+import { type Patient, type FHIREncounter, MortuaryLocationResponse, Entry } from '../../types';
+import { useMemo, useState } from 'react';
+import { parseDisplayText } from '../../utils/utils';
+
+export const useMortuaryDischargeEncounter = (
+  dischargeEncounterTypeUuid: string,
+  admissionLocation: MortuaryLocationResponse,
+) => {
+  const pageSizes = [10, 20, 50, 100];
+  const locationUuid = admissionLocation?.ward?.uuid;
+  const [currPageSize, setCurrPageSize] = useState(10);
+  const urls = !admissionLocation
+    ? null
+    : `${fhirBaseUrl}/Encounter?_summary=data&type=${dischargeEncounterTypeUuid}&location=${locationUuid}`;
+  const { data, isLoading, error, paginated, currentPage, goTo, totalCount, currentPageSize, mutate } =
+    useFhirPagination<Entry>(urls, currPageSize);
+
+  const dischargedPatientUuids = useMemo(() => {
+    if (!data) {
+      return [];
+    }
+
+    const uuids = data
+      .map((entry) => {
+        const reference = entry?.subject?.reference;
+        if (reference && reference.startsWith('Patient/')) {
+          return reference.split('/')[1];
+        }
+        return undefined;
+      })
+      .filter((uuid) => uuid);
+
+    const admittedPatientUuids = admissionLocation?.bedLayouts
+      ?.flatMap((bed) => bed.patients?.map((patient) => patient.uuid))
+      .filter(Boolean);
+
+    const filteredDischargedPatientUuids = uuids?.filter((uuid) => !admittedPatientUuids?.includes(uuid));
+
+    return [...new Set(filteredDischargedPatientUuids)];
+  }, [data, admissionLocation]);
+
+  const encounters = useMemo(() => {
+    return (data ?? []).map((entry) => {
+      const { name, openmrsId } = parseDisplayText(entry.subject.display);
+      const patientUuid = entry.subject.reference.split('/').at(-1);
+      return {
+        uuid: entry?.id,
+        patient: { uuid: patientUuid, openmrsId, name },
+        encounterDateTime: entry.period?.start,
+      };
+    });
+  }, [data]);
+
+  return {
+    encounters,
+    dischargedPatientUuids,
+    isLoading: isLoading,
+    error: error,
+    paginated,
+    currentPage,
+    pageSizes,
+    goTo,
+    currPageSize,
+    setCurrPageSize,
+    totalCount,
+    currentPageSize,
+    mutate,
+  };
+};
+
+export const usePatients = (uuids: string[]) => {
+  const customRepresentation =
+    'custom:(uuid,display,identifiers:(uuid,display),person:(uuid,display,gender,birthdate,dead,age,deathDate,causeOfDeath:(uuid,display),attributes:(uuid,display,value,attributeType:(uuid,))))';
+  const urls = uuids.map((uuid) => `${restBaseUrl}/patient/${uuid}?v=${customRepresentation}`);
+
+  const { data, error, isLoading, mutate } = useSWR<FetchResponse<Patient>[]>(urls, (urls) =>
+    Promise.all(urls.map((url) => openmrsFetch<Patient>(url))),
+  );
+
+  const deceasedPatients = data?.map((response) => response.data)?.filter((patient) => patient?.person?.dead === true);
+
+  return {
+    isLoading,
+    error,
+    patients: deceasedPatients,
+    mutate,
+  };
+};
+
+export default usePatients;