@kenyaemr/esm-morgue-app 5.4.1-pre.1848 → 5.4.1-pre.1850

package/src/extension/actionButton.component.tsx

@@ -0,0 +1,74 @@
+import { Button } from '@carbon/react';
+import { useTranslation } from 'react-i18next';
+import { launchWorkspace, navigate } from '@openmrs/esm-framework';
+import { Movement, Return, ShareKnowledge } from '@carbon/react/icons';
+import React from 'react';
+import { useAdmissionLocation } from '../hook/useMortuaryAdmissionLocation';
+import styles from './actionButton.scss';
+
+interface ActionButtonProps {
+  patientUuid: string;
+}
+
+const ActionButton: React.FC<ActionButtonProps> = ({ patientUuid }) => {
+  const { t } = useTranslation();
+  const { admissionLocation, isLoading, error } = useAdmissionLocation();
+
+  const isPatientInAdmissionLocation = admissionLocation?.bedLayouts?.some((bed) =>
+    bed.patients.some((patient) => patient.uuid === patientUuid),
+  );
+
+  const bedId = admissionLocation?.bedLayouts?.find((bed) =>
+    bed.patients.some((patient) => patient.uuid === patientUuid),
+  )?.bedId;
+
+  const personUuid = admissionLocation?.bedLayouts
+    ?.find((bed) => bed.patients.some((patient) => patient.uuid === patientUuid))
+    ?.patients.find((patient) => patient.uuid === patientUuid)?.person?.uuid;
+
+  const handleNavigateToAllocationPage = () =>
+    navigate({
+      to: window.getOpenmrsSpaBase() + `home/morgue/allocation`,
+    });
+
+  const handleDischargeForm = (uuid: string, bedId: number) => {
+    launchWorkspace('discharge-body-form', {
+      workspaceTitle: t('dischargeForm', 'Discharge form'),
+      patientUuid: uuid,
+      bedId,
+      personUuid,
+    });
+  };
+
+  const handleSwapForm = (uuid: string, bedId: number) => {
+    launchWorkspace('swap-unit-form', {
+      workspaceTitle: t('swapCompartment', 'Swap compartment'),
+      patientUuid: uuid,
+      bedId,
+    });
+  };
+
+  return (
+    <div className={styles.actionButton}>
+      <Button kind="primary" size="sm" renderIcon={Return} onClick={handleNavigateToAllocationPage}>
+        {t('allocation', 'Allocation View')}
+      </Button>
+      {isPatientInAdmissionLocation && (
+        <>
+          <Button
+            kind="secondary"
+            size="sm"
+            renderIcon={ShareKnowledge}
+            onClick={() => handleSwapForm(patientUuid, bedId)}>
+            {t('swapCompartment', 'Swap compartment')}
+          </Button>
+          <Button kind="danger" size="sm" renderIcon={Movement} onClick={() => handleDischargeForm(patientUuid, bedId)}>
+            {t('discharge', 'Discharge body')}
+          </Button>
+        </>
+      )}
+    </div>
+  );
+};
+
+export default ActionButton;

package/src/extension/actionButton.scss

@@ -0,0 +1,69 @@
+@use '@carbon/layout';
+@use '@carbon/type';
+@use '@carbon/colors';
+
+.actionButton {
+  display: flex;
+  gap: layout.$spacing-03;
+}
+
+.metrics {
+  display: flex;
+  flex-direction: row;
+  justify-content: flex-end;
+  align-items: center;
+  gap: layout.$spacing-06;
+  flex-wrap: wrap;
+  padding: layout.$spacing-04 layout.$spacing-05 0 0;
+  width: auto;
+  height: auto;
+}
+
+.wrapMetrics {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: flex-start;
+  gap: layout.$spacing-03;
+  padding: 0;
+  min-width: layout.$spacing-12;
+}
+
+.metricLabel {
+  flex-grow: 0;
+  font-size: layout.$spacing-04;
+  line-height: 1.33;
+  letter-spacing: 0.32px;
+  text-align: left;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.metricValue {
+  flex-grow: 0;
+  font-size: type.type-scale(2);
+  color: colors.$gray-60;
+  line-height: 1.4;
+  text-align: left;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.metricLocationDate {
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-start;
+  align-items: flex-start;
+  gap: layout.$spacing-05;
+  width: auto;
+  max-width: 120px;
+}
+
+.metricList {
+  display: flex;
+  flex-flow: row wrap;
+  padding-bottom: layout.$spacing-03;
+  margin: 0 layout.$spacing-05;
+}

package/src/extension/deceasedInfoBanner.component.tsx

@@ -0,0 +1,57 @@
+import { Button } from '@carbon/react';
+import { useTranslation } from 'react-i18next';
+import { launchWorkspace, navigate, usePatient, useVisit } from '@openmrs/esm-framework';
+import { Movement, Return, ShareKnowledge } from '@carbon/react/icons';
+import React from 'react';
+import { useAdmissionLocation } from '../hook/useMortuaryAdmissionLocation';
+import styles from './actionButton.scss';
+import { convertDateToDays, formatDateTime } from '../utils/utils';
+import { Console } from '@carbon/pictograms-react';
+
+interface BannerInfoProps {
+  patientUuid: string;
+}
+
+const BannerInfo: React.FC<BannerInfoProps> = ({ patientUuid }) => {
+  const { t } = useTranslation();
+  const { admissionLocation, isLoading, error } = useAdmissionLocation();
+  const { patient } = usePatient(patientUuid);
+  const { currentVisit } = useVisit(patientUuid);
+
+  const bedNumber =
+    admissionLocation?.bedLayouts?.find((bed) => bed.patients.some((patient) => patient.uuid === patientUuid))
+      ?.bedNumber || t('discharged', 'Discharged');
+
+  const timeAndDateOfDeath = patient?.deceasedDateTime;
+
+  const startDate = currentVisit?.startDatetime;
+
+  const lengthOfStay = `${convertDateToDays(startDate)} ${
+    convertDateToDays(startDate) === 1 ? t('day', 'Day') : t('days', 'Days')
+  }`;
+
+  return (
+    <div className={styles.metricList}>
+      <div className={styles.metrics}>
+        <div className={styles.wrapMetrics}>
+          <span className={styles.metricLabel}>{t('dateOfAdmission', 'Date of admission')}</span>
+          <span className={styles.metricValue}>{formatDateTime(startDate)}</span>
+        </div>
+        <div className={styles.wrapMetrics}>
+          <span className={styles.metricLabel}>{t('dateAndTimeofDeath', 'Date and time of death')}</span>{' '}
+          <span className={styles.metricValue}>{formatDateTime(timeAndDateOfDeath)}</span>
+        </div>
+        <div className={styles.wrapMetrics}>
+          <span className={styles.metricLabel}>{t('lengthofStay', 'Length of stay')}</span>
+          <span className={styles.metricValue}>{lengthOfStay}</span>
+        </div>
+        <div className={styles.wrapMetrics}>
+          <span className={styles.metricLabel}>{t('compartment', 'Compartment')}</span>
+          <span className={styles.metricValue}>{bedNumber}</span>
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default BannerInfo;

package/src/hook/useAdmitPatient.ts

@@ -0,0 +1,285 @@
+import {
+  closeWorkspace,
+  FetchResponse,
+  openmrsFetch,
+  restBaseUrl,
+  showSnackbar,
+  updateVisit,
+  useConfig,
+  useSession,
+  type Visit,
+} from '@openmrs/esm-framework';
+import dayjs from 'dayjs';
+import { useCallback, useMemo } from 'react';
+import useSWR from 'swr';
+import useSWRImmutable from 'swr/immutable';
+import { z } from 'zod';
+import { ConfigObject } from '../config-schema';
+import {
+  CurrentLocationEncounterResponse,
+  customRepProps,
+  EmrApiConfigurationResponse,
+  Encounter,
+  MappedVisitQueueEntry,
+  VisitQueueEntry,
+} from '../types';
+import { dischargeSchema, patientInfoSchema } from '../utils/utils';
+import { useMortuaryLocation } from './useMortuaryAdmissionLocation';
+import { removeQueuedPatient } from './useMorgue.resource';
+const customRep = `custom:${customRepProps.map((prop) => prop.join(':')).join(',')}`;
+
+export default function useEmrConfiguration() {
+  const swrData = useSWRImmutable<FetchResponse<EmrApiConfigurationResponse>>(
+    `${restBaseUrl}/emrapi/configuration?v=${customRep}`,
+    openmrsFetch,
+  );
+
+  const results = useMemo(
+    () => ({
+      emrConfiguration: swrData.data?.data,
+      isLoadingEmrConfiguration: swrData.isLoading,
+      mutateEmrConfiguration: swrData.mutate,
+      errorFetchingEmrConfiguration: swrData.error,
+    }),
+    [swrData],
+  );
+  return results;
+}
+
+export const useMortuaryOperation = () => {
+  const { location } = useMortuaryLocation();
+  const { currentProvider } = useSession();
+  const { emrConfiguration, isLoadingEmrConfiguration, errorFetchingEmrConfiguration } = useEmrConfiguration();
+  const {
+    visitPaymentMethodAttributeUuid,
+    tagNumberUuid,
+    obNumberUuid,
+    burialPermitNumberUuid,
+    policeNameUuid,
+    policeIDNumber,
+    dischargeAreaUuid,
+  } = useConfig<ConfigObject>();
+
+  const createMortuaryAdmissionEncounter = useCallback(
+    async (
+      patientUuid: string,
+      {
+        availableCompartment,
+        dateOfAdmission,
+        insuranceScheme,
+        dischargeArea,
+        obNumber,
+        paymentMethod,
+        period,
+        policeIDNo,
+        policeName,
+        tagNumber,
+        visitType,
+      }: z.infer<typeof patientInfoSchema>,
+    ) => {
+      const obs = [];
+      if (tagNumber) {
+        obs.push({ concept: tagNumberUuid, value: tagNumber });
+      }
+      if (obNumber) {
+        obs.push({ concept: obNumberUuid, value: obNumber });
+      }
+      if (policeName) {
+        obs.push({ concept: policeNameUuid, value: policeName });
+      }
+      if (policeIDNo) {
+        obs.push({ concept: policeIDNumber, value: policeIDNo });
+      }
+      if (dischargeArea) {
+        obs.push({ concept: dischargeAreaUuid, value: dischargeArea });
+      }
+      const encounterPayload = {
+        visit: {
+          patient: patientUuid,
+          startDatetime: dayjs(dateOfAdmission).toISOString(),
+          visitType: visitType,
+          location: location?.uuid,
+          attributes: [
+            {
+              attributeType: visitPaymentMethodAttributeUuid,
+              value: paymentMethod,
+            },
+          ],
+        },
+        patient: patientUuid,
+        encounterType: emrConfiguration?.admissionEncounterType?.uuid,
+        location: location?.uuid,
+        encounterProviders: [
+          {
+            provider: currentProvider?.uuid,
+            encounterRole: emrConfiguration?.clinicianEncounterRole?.uuid,
+          },
+        ],
+        obs: obs.length > 0 ? obs : undefined,
+      };
+      return openmrsFetch<Encounter>(`${restBaseUrl}/encounter`, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+        },
+        body: encounterPayload,
+      });
+    },
+    [
+      currentProvider?.uuid,
+      dischargeAreaUuid,
+      emrConfiguration?.admissionEncounterType?.uuid,
+      emrConfiguration?.clinicianEncounterRole?.uuid,
+      location?.uuid,
+      obNumberUuid,
+      policeIDNumber,
+      policeNameUuid,
+      tagNumberUuid,
+      visitPaymentMethodAttributeUuid,
+    ],
+  );
+
+  const assignDeceasedToCompartment = useCallback(
+    async (patientUuid: string, bedId: number, encounterUuid: string) =>
+      openmrsFetch(`${restBaseUrl}/beds/${bedId}`, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+        },
+        body: {
+          patientUuid,
+          encounterUuid,
+        },
+      }),
+    [],
+  );
+
+  const admitBody = useCallback(
+    async (patientUuid: string, data: z.infer<typeof patientInfoSchema>) => {
+      const admissionEncounter = await createMortuaryAdmissionEncounter(patientUuid, data);
+      const compartment = await assignDeceasedToCompartment(
+        patientUuid,
+        data.availableCompartment,
+        admissionEncounter.data.uuid,
+      );
+      return { admissionEncounter, compartment };
+    },
+    [assignDeceasedToCompartment, createMortuaryAdmissionEncounter],
+  );
+
+  const createDischargeMortuaryEncounter = useCallback(
+    async (visit: Visit, data: z.infer<typeof dischargeSchema>) => {
+      const obs = [];
+      if (data.burialPermitNumber) {
+        obs.push({ concept: burialPermitNumberUuid, value: data.burialPermitNumber });
+      }
+
+      const encounterPayload = {
+        encounterDatetime: data?.dateOfDischarge,
+        patient: visit?.patient?.uuid,
+        encounterType: emrConfiguration?.exitFromInpatientEncounterType,
+        location: visit?.location?.uuid,
+        encounterProviders: [
+          {
+            provider: currentProvider?.uuid,
+            encounterRole: emrConfiguration?.clinicianEncounterRole?.uuid,
+          },
+        ],
+        visit: visit?.uuid,
+        obs: obs.length > 0 ? obs : undefined,
+      };
+      return openmrsFetch<Encounter>(`${restBaseUrl}/encounter`, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+        },
+        body: encounterPayload,
+      });
+    },
+    [
+      burialPermitNumberUuid,
+      currentProvider?.uuid,
+      emrConfiguration?.clinicianEncounterRole?.uuid,
+      emrConfiguration?.exitFromInpatientEncounterType,
+    ],
+  );
+  const removeDeceasedFromCompartment = useCallback(
+    async (patientUuid: string, bedId: number) =>
+      openmrsFetch(`${restBaseUrl}/beds/${bedId}?patientUuid=${patientUuid}`, {
+        method: 'DELETE',
+      }),
+    [],
+  );
+
+  const endCurrentVisit = useCallback(
+    async (currentVisit: Visit, queueEntry: MappedVisitQueueEntry, data: z.infer<typeof dischargeSchema>) => {
+      const abortController = new AbortController();
+      const response = await updateVisit(
+        currentVisit.uuid,
+        {
+          stopDatetime: new Date(),
+        },
+        abortController,
+      );
+
+      if (queueEntry) {
+        removeQueuedPatient(
+          queueEntry.queue.uuid,
+          queueEntry.queueEntryUuid,
+          abortController,
+          response?.data?.stopDatetime,
+        );
+      }
+    },
+    [],
+  );
+
+  const dischargeBody = useCallback(
+    async (visit: Visit, queueEntry: MappedVisitQueueEntry, bedId: number, data: z.infer<typeof dischargeSchema>) => {
+      const dischargeEncounter = await createDischargeMortuaryEncounter(visit, data);
+      const compartment = await removeDeceasedFromCompartment(visit?.patient?.uuid, bedId);
+      await endCurrentVisit(visit, queueEntry, data);
+      return { dischargeEncounter, compartment };
+    },
+    [createDischargeMortuaryEncounter, endCurrentVisit, removeDeceasedFromCompartment],
+  );
+  const createEncounterForCompartmentSwap = useCallback(
+    async (patientUuid: string, visitUuid: string) =>
+      openmrsFetch<Encounter>(`${restBaseUrl}/encounter`, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+        },
+        body: {
+          encounterDatetime: new Date(),
+          patient: patientUuid,
+          encounterType: emrConfiguration?.bedAssignmentEncounterType,
+          location: location?.uuid,
+          encounterProviders: [
+            {
+              provider: currentProvider?.uuid,
+              encounterRole: emrConfiguration?.clinicianEncounterRole?.uuid,
+            },
+          ],
+          visit: visitUuid,
+          obs: [],
+        },
+      }),
+    [
+      currentProvider?.uuid,
+      emrConfiguration?.bedAssignmentEncounterType,
+      emrConfiguration?.clinicianEncounterRole?.uuid,
+      location?.uuid,
+    ],
+  );
+
+  return {
+    admitBody,
+    createEncounterForCompartmentSwap,
+    assignDeceasedToCompartment,
+    removeDeceasedFromCompartment,
+    dischargeBody,
+    isLoadingEmrConfiguration,
+    errorFetchingEmrConfiguration,
+  };
+};

package/src/hook/useDeceasedPatients.ts

@@ -0,0 +1,12 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { PaginatedResponse } from '../types';
+export async function fetchDeceasedPatient(query: string, abortController: AbortController) {
+  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)))';
+  const url = `${restBaseUrl}/morgue/patient?v=${customRepresentation}&dead=true&name=${query}`;
+
+  const resp = await openmrsFetch<{ results: Array<PaginatedResponse> }>(url, {
+    signal: abortController.signal,
+  });
+  return resp?.data?.results;
+}

package/src/hook/useDischargedPatient.ts

@@ -0,0 +1,55 @@
+import { FetchResponse, openmrsFetch, restBaseUrl, useFhirFetchAll } from '@openmrs/esm-framework';
+import { type Patient, type FHIREncounter } from '../types';
+import { useAdmissionLocation } from './useMortuaryAdmissionLocation';
+import useSWR from 'swr';
+
+export const useDischargedPatient = (dischargeEncounterTypeUuid: string) => {
+  const url = dischargeEncounterTypeUuid
+    ? `/ws/fhir2/R4/Encounter?_format=json&type=${dischargeEncounterTypeUuid}`
+    : null;
+  const { data, error, isLoading } = useFhirFetchAll<FHIREncounter>(url);
+
+  const dischargedPatientUuids = data
+    ?.map((encounter) => {
+      const reference = encounter.subject?.reference;
+      if (reference && reference.startsWith('Patient/')) {
+        return reference.split('/')[1];
+      }
+      return undefined;
+    })
+    .filter((uuid) => uuid);
+
+  const { admissionLocation } = useAdmissionLocation();
+
+  const admittedPatientUuids = admissionLocation?.bedLayouts
+    ?.flatMap((bed) => bed.patients?.map((patient) => patient.uuid))
+    .filter(Boolean);
+
+  const filteredDischargedPatientUuids = dischargedPatientUuids?.filter(
+    (uuid) => !admittedPatientUuids?.includes(uuid),
+  );
+
+  const uniqueDischargedPatientUuids = [...new Set(filteredDischargedPatientUuids)];
+
+  return { dischargedPatientUuids: uniqueDischargedPatientUuids, error, isLoading };
+};
+
+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 } = 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,
+  };
+};
+
+export default usePatients;