@ampath/esm-dha-workflow-app 4.0.0-next.13 → 4.0.0-next.131

package/src/admissions/admissions.resource.ts

@@ -0,0 +1,101 @@
+import { Encounter, fhirBaseUrl, FHIRResource, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { AdmitPatientDto, AssignBedToPatientDto, BedLayout, BedSwapDto, CancelAdmissionDto, DischargePatientDto, Disposition, DispositionResponse, FhirEncounterBundle, TransferPatientDto, UnAssignBedDto, type AdmissionLocationData } from './types';
+
+const customRep =
+  'custom:(ward,totalBeds,occupiedBeds,bedLayouts:(rowNumber,columnNumber,bedNumber,bedId,bedUuid,status,location,patients:(person:full,identifiers,uuid)))';
+
+export async function getAdmissionLoactionData(locationUuid: string): Promise<AdmissionLocationData> {
+  const admissionLocationUrl = `${restBaseUrl}/admissionLocation/${locationUuid}?v=${customRep}`;
+  const response = await openmrsFetch(admissionLocationUrl);
+  const result = await response.json();
+  return result ?? null;
+}
+
+export async function getAdmissionRequests(locationUuid: string): Promise<Disposition[]> {
+  const admissionRep = 'custom:(dispositionLocation,dispositionType,disposition,dispositionEncounter:full,patient:(uuid,identifiers,voided,person:(uuid,display,gender,age,birthdate,birthtime,preferredName,preferredAddress,dead,deathDate)),dispositionObsGroup,visit)';
+  const params = {
+    v: admissionRep,
+    dispositionLocation: locationUuid,
+    dispositionType: 'ADMIT,TRANSFER'
+  };
+  const queryString = new URLSearchParams(params).toString();
+  const admissionRequestUrl = `${restBaseUrl}/emrapi/inpatient/request?${queryString}`;
+  const response = await openmrsFetch(admissionRequestUrl);
+  const result = await response.json();
+  return result.results ?? null;
+}
+
+export async function getAdmittedPatientsData(locationUuid: string): Promise<BedLayout[]> {
+  const admissionLocationData = await getAdmissionLoactionData(locationUuid);
+  if (admissionLocationData.bedLayouts && admissionLocationData.bedLayouts.length > 0) {
+    const bedLayouts = admissionLocationData.bedLayouts;
+    return bedLayouts;
+  } else {
+    return [];
+  }
+}
+
+export async function postRequest(url: string, dto: any) {
+  const resp = await openmrsFetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(dto),
+  });
+  const result = await resp.json();
+  return result;
+}
+
+export async function admitPatientToWard(admitPatientDto: AdmitPatientDto): Promise<Encounter> {
+  const admitPatientUrl = `${restBaseUrl}/encounter`;
+  return postRequest(admitPatientUrl, admitPatientDto);
+}
+
+export async function assignBedToPatient(bedId: number, assignBedToPatientDto: AssignBedToPatientDto) {
+  const assignBedUrl = `${restBaseUrl}/beds/${bedId}`;
+  return postRequest(assignBedUrl, assignBedToPatientDto);
+}
+
+export async function cancelAdmissionRequest(cancelAdmissionDto: CancelAdmissionDto) {
+  const cancelAdmissionUrl = `${restBaseUrl}/encounter`;
+  return postRequest(cancelAdmissionUrl, cancelAdmissionDto);
+}
+
+export async function bedSwapRequest(bedSwapDto: BedSwapDto) {
+  const cancelAdmissionUrl = `${restBaseUrl}/encounter`;
+  return postRequest(cancelAdmissionUrl, bedSwapDto);
+}
+
+export async function dischargePatientFromWard(dischargePatientDto: DischargePatientDto) {
+  const cancelAdmissionUrl = `${restBaseUrl}/encounter`;
+  return postRequest(cancelAdmissionUrl, dischargePatientDto);
+}
+
+export async function unassignBed(unAssignBedDto: UnAssignBedDto) {
+  const params = {
+    patientUuid: unAssignBedDto.patientUuid
+  };
+  const queryString = new URLSearchParams(params).toString();
+  const unassignBedUrl = `${restBaseUrl}/beds/${unAssignBedDto.bedId}?${queryString}`;
+  await openmrsFetch(unassignBedUrl, {
+    method: 'DELETE'
+  });
+  return true;
+}
+export async function admitPatientElseWhere(transferPatientDto: TransferPatientDto) {
+  const transferUrl = `${restBaseUrl}/encounter`;
+  return postRequest(transferUrl, transferPatientDto);
+}
+export async function getDichargedEncounters(encounterTypeUuid: string,locationUuid: string): Promise<FhirEncounterBundle>{
+  const params = {
+    _summary: 'data',
+    type: encounterTypeUuid,
+    location: locationUuid,
+    _count: '100',
+    _getpagesoffset: '0'
+  };
+  const queryString = new URLSearchParams(params).toString();
+  const encountersUrl = `${fhirBaseUrl}/Encounter?${queryString}`;
+  const resp = await openmrsFetch(encountersUrl);
+  const result = await resp.json();
+  return result;
+}

package/src/admissions/admitted-list/admitted-patients-list.tsx

@@ -0,0 +1,141 @@
+import React, { useState } from 'react';
+import {
+  OverflowMenu,
+  OverflowMenuItem,
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@carbon/react';
+import { type BedLayout } from '../types';
+import BedSwapModal from '../modal/bed-swap/bed-swap.modal';
+import DischargeModal from '../modal/discharge/discharge-patient.modal';
+
+interface AdmittedPatientsListProps {
+  admittedPatientsData: BedLayout[];
+  refresh: () => void;
+}
+
+const AdmittedPatientsList: React.FC<AdmittedPatientsListProps> = ({ admittedPatientsData, refresh }) => {
+  const [showBedSwapModal, setShowBedSwapModal] = useState<boolean>(false);
+  const [showDischargeModal, setShowDischargeModal] = useState<boolean>(false);
+  const [selectedLayout, setSelectedLayout] = useState<any>();
+  if (!admittedPatientsData) {
+    return <>No data to display</>;
+  }
+  const handleTransferRequest = (layout: BedLayout) => {
+    setSelectedLayout(layout);
+  };
+  const handleBedSwapRequest = (layout: BedLayout) => {
+    setSelectedLayout(layout);
+    setShowBedSwapModal(true);
+  };
+  const handleDischargeRequest = (layout: BedLayout) => {
+    setSelectedLayout(layout);
+    setShowDischargeModal(true);
+  };
+  const handleBedSwapModalClose = () => {
+    setShowBedSwapModal(false);
+    refresh();
+  };
+  const handleDischargeModalClose = () => {
+    setShowDischargeModal(false);
+  };
+  const handleSuccessfullDischarge = () => {
+    handleBedSwapModalClose();
+    refresh();
+  };
+  const rows =
+    admittedPatientsData?.flatMap((layout) =>
+      (layout.patients ?? []).map((patient) => ({
+        key: `${layout.bedUuid}-${patient.uuid}`,
+        bedNumber: layout.bedNumber,
+        bedId: layout.bedId,
+        status: layout.status,
+        location: layout.location,
+        name: patient.person.display,
+        gender: patient.person.gender,
+        age: patient.person.age,
+        identifier: patient.identifiers?.[0]?.identifier ?? 'N/A',
+        person: patient.person,
+      })),
+    ) ?? [];
+
+  if (!rows.length) {
+    return <>No Data</>;
+  }
+
+  return (
+    <>
+      <Table>
+        <TableHead>
+          <TableRow>
+            <TableHeader>No</TableHeader>
+            <TableHeader>Bed No</TableHeader>
+            <TableHeader>Patient Name</TableHeader>
+            <TableHeader>Gender</TableHeader>
+            <TableHeader>Age</TableHeader>
+            <TableHeader>Identifier</TableHeader>
+            <TableHeader>Status</TableHeader>
+            <TableHeader>Location</TableHeader>
+            <TableHeader>Action</TableHeader>
+          </TableRow>
+        </TableHead>
+        <TableBody>
+          {rows.map((row, index) => (
+            <TableRow key={row.key}>
+              <TableCell>{index + 1}</TableCell>
+              <TableCell>{row.bedNumber}</TableCell>
+              <TableCell>{row.name}</TableCell>
+              <TableCell>{row.gender}</TableCell>
+              <TableCell>{row.age}</TableCell>
+              <TableCell>{row.identifier}</TableCell>
+              <TableCell>{row.status}</TableCell>
+              <TableCell>{row.location}</TableCell>
+              <TableCell>
+                <>
+                  <OverflowMenu aria-label="overflow-menu">
+                    <OverflowMenuItem itemText="Transfer" onClick={() => handleTransferRequest(row as any)} />
+                    <OverflowMenuItem itemText="Bed Swap" onClick={() => handleBedSwapRequest(row as any)} />
+                    <OverflowMenuItem itemText="Discharge" onClick={() => handleDischargeRequest(row as any)} />
+                  </OverflowMenu>
+                </>
+              </TableCell>
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+      {showBedSwapModal && selectedLayout ? (
+        <>
+          <BedSwapModal
+            open={showBedSwapModal}
+            onModalClose={handleBedSwapModalClose}
+            onSuccessfullBedSwap={handleBedSwapModalClose}
+            disposition={null}
+            person={selectedLayout.person}
+            bedLayouts={admittedPatientsData}
+          />
+        </>
+      ) : (
+        <></>
+      )}
+
+      {showDischargeModal && selectedLayout ? (
+        <>
+          <DischargeModal
+            open={showDischargeModal}
+            onModalClose={handleDischargeModalClose}
+            onDischarge={handleSuccessfullDischarge}
+            admissionRequest={selectedLayout}
+          />
+        </>
+      ) : (
+        <></>
+      )}
+    </>
+  );
+};
+
+export default AdmittedPatientsList;

package/src/admissions/constants/index.ts

@@ -0,0 +1,33 @@
+const ADMIT_ENCOUNTER_TYPE_UUID = 'e22e39fd-7db2-45e7-80f1-60fa0d5a4378';
+const CANCEL_ADT_ENCOUNTER_TYPE_UUID = "550e8400-e29b-41d4-a716-446655440000";
+const BED_ASSIGNMENT_ENCOUNTER_TYPE_UUID = 'f47ac10b-58cc-4372-a567-0e02b2c3d479';
+const DISCHARGE_ENCOUNTER_TYPE_UUID = '181820aa-88c9-479b-9077-af92f5364329';
+const TRANSFER_REQUEST_ENCOUNTER_TYPE_UUID = 'b2c4d5e6-7f8a-4e9b-8c1d-2e3f8e4a3b8f';
+
+const ADMISSION_TO_HOSPITAL_DECISION_UUID = 'ac4d3e94-03f3-458a-9cb1-9c2ab3c3a3f7';
+const ADMISSION_DENIED_UUID = 'cc6a6126-b8a1-4d2d-9a35-31f9be7c5e68';
+const CLINICAL_IMPRESSION_UUID = '159395AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';
+const CLINICAL_NOTES_UUID = '5e4dc798-2cce-4a1a-97e9-bcf22d64b07c';
+const INPATIENT_DISPOSITION_CONSTRUCT_UUID = '9ceedfb7-60e4-42ce-a11e-f2dbabc82112';
+const INTERNAL_TRANSFER_LOCATION_UUID = '731318a6-9fa9-4f68-97a9-5bd4cbc707f7';
+const INPATIENT_PATIENT_DISPOSITION_UUID = 'ce085d74-323c-4c9a-9fdf-051de81dd020';
+const TRANSFER_OUT_UUID = '5520f234-258e-49f0-97ab-701b98fab608';
+
+export const AdmissionEncounterTypeUuids = {
+    ADMIT_ENCOUNTER_TYPE_UUID,
+    CANCEL_ADT_ENCOUNTER_TYPE_UUID,
+    BED_ASSIGNMENT_ENCOUNTER_TYPE_UUID,
+    DISCHARGE_ENCOUNTER_TYPE_UUID,
+    TRANSFER_REQUEST_ENCOUNTER_TYPE_UUID
+};
+
+export const AdmissionConcepts = {
+ADMISSION_TO_HOSPITAL_DECISION_UUID,
+ADMISSION_DENIED_UUID,
+CLINICAL_IMPRESSION_UUID,
+CLINICAL_NOTES_UUID,
+INPATIENT_DISPOSITION_CONSTRUCT_UUID,
+INTERNAL_TRANSFER_LOCATION_UUID,
+INPATIENT_PATIENT_DISPOSITION_UUID,
+TRANSFER_OUT_UUID
+}

package/src/admissions/discharged-list/discharged-list.tsx

@@ -0,0 +1,58 @@
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@carbon/react";
+import React from "react";
+import { FhirEncounter } from "../types";
+import { formatDate } from "@openmrs/esm-framework";
+interface DischargedListProps{
+    dischargedEncounters: FhirEncounter[];
+    refresh: () => void;
+}
+const DischargedList: React.FC<DischargedListProps> = ({dischargedEncounters,refresh})=>{
+    if(!dischargedEncounters){
+       return <>No Data to display</>
+    }
+    const getPatientName = (display: string): string=>{
+         const splitString = display.split("(");
+         let names = '';
+         if(splitString.length > 0){
+            names = splitString[0];
+         }
+         return names;
+    };
+    const getPatientIdentifier = (display: string): string=>{
+        const splitString = display.split("(");
+        let identifier = '';
+        if(splitString.length > 1){
+           identifier = splitString[1];
+        }
+        return identifier;
+    }
+   return <>
+      <Table>
+        <TableHead>
+          <TableRow>
+            <TableHeader>No</TableHeader>
+            <TableHeader>Discharge Date</TableHeader>
+            <TableHeader>Name</TableHeader>
+            <TableHeader>Identifier</TableHeader>
+          </TableRow>
+        </TableHead>
+
+        <TableBody>
+          {
+          dischargedEncounters.map((val,index)=>{
+              return <>
+              <TableRow key={val.id}>
+              <TableCell>{index + 1}</TableCell>
+              <TableCell>{formatDate(new Date(val.period.start))}</TableCell>
+              <TableCell>{getPatientName(val.subject.display ?? '')}</TableCell>
+              <TableCell>{getPatientIdentifier(val.subject.display ?? '')}</TableCell>
+            </TableRow>
+            </>
+          })
+           
+            }
+        </TableBody>
+      </Table>
+   </>
+}
+export default DischargedList;

package/src/admissions/inpatient/admission-history/patient-admission-history.tsx

@@ -0,0 +1,76 @@
+import React, { useEffect, useMemo, useState } from 'react';
+import { Table, TableHead, TableRow, TableHeader, TableBody, TableCell } from '@carbon/react';
+import { getPatientEncounters } from '../../../shared/services/encounters.resource';
+import { type Encounter, formatDate, parseDate } from '@openmrs/esm-framework';
+import { AdmissionEncounterTypeUuids } from '../../constants';
+interface PatientAdmissionHistoryProps {
+  patientUuid: string;
+}
+const PatientAdmissionHistory: React.FC<PatientAdmissionHistoryProps> = ({ patientUuid }) => {
+  const [encounters, setEncounters] = useState<Encounter[]>([]);
+  const admissionEncounterTypes = useMemo(
+    () =>
+      Object.keys(AdmissionEncounterTypeUuids).map((k) => {
+        return AdmissionEncounterTypeUuids[k];
+      }),
+    [patientUuid],
+  );
+  const admissionEncounters = useMemo(() => generateAdmissionEncounters(), [encounters, patientUuid]);
+
+  useEffect(() => {
+    if (!patientUuid) return;
+    fetchPatientAdmissionHistory(patientUuid);
+  }, [patientUuid]);
+
+  async function fetchPatientAdmissionHistory(patientUuid: string) {
+    const resp = await getPatientEncounters(patientUuid);
+    setEncounters(resp);
+  }
+
+  function generateAdmissionEncounters(): Encounter[] {
+    return encounters
+      .filter((e) => {
+        return admissionEncounterTypes.includes(e.encounterType.uuid);
+      })
+      .sort((a, b) => {
+        return b.encounterDatetime.localeCompare(a.encounterDatetime);
+      });
+  }
+
+  if (!patientUuid) {
+    return <>No patient specified</>;
+  }
+
+  return (
+    <>
+      <Table aria-label="sample table" size="lg">
+        <TableHead>
+          <TableRow>
+            <TableHeader>No</TableHeader>
+            <TableHeader>Encounter</TableHeader>
+            <TableHeader>Date</TableHeader>
+            <TableHeader>Location</TableHeader>
+          </TableRow>
+        </TableHead>
+        <TableBody>
+          {admissionEncounters ? (
+            admissionEncounters.map((encounter, index) => {
+              return (
+                <TableRow>
+                  <TableCell>{index + 1}</TableCell>
+                  <TableCell>{encounter?.display ?? ''}</TableCell>
+                  <TableCell>{formatDate(parseDate(encounter.encounterDatetime))}</TableCell>
+                  <TableCell>{encounter.location.display}</TableCell>
+                </TableRow>
+              );
+            })
+          ) : (
+            <></>
+          )}
+        </TableBody>
+      </Table>
+    </>
+  );
+};
+
+export default PatientAdmissionHistory;

package/src/admissions/inpatient/admission-requests/patient-admission-requests.scss

@@ -0,0 +1,19 @@
+.admissionLayout{
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    row-gap: 10px;
+    .actionSection{
+        display: flex;
+        flex-direction: row;
+        column-gap: 10px;
+        margin: 10px 10px;
+        justify-content: flex-end;
+    }
+    .contentSection{
+        display: flex;
+        flex-direction: column;
+        width: 100%;
+        row-gap: 10px;
+    }
+}

package/src/admissions/inpatient/admission-requests/patient-admission-requests.tsx

@@ -0,0 +1,72 @@
+import React, { useEffect, useState } from 'react';
+import { DataTable, Table, TableHead, TableRow, TableHeader, TableBody, TableCell, Button } from '@carbon/react';
+import { fetchPatientEncountersByType } from '../../../shared/services/encounters.resource';
+import { formatDate, parseDate } from '@openmrs/esm-framework';
+import styles from './patient-admission-requests.scss';
+
+interface PatientAdmisssionRequestsProps {
+  patientUuid: string;
+}
+const PatientAdmisssionRequests: React.FC<PatientAdmisssionRequestsProps> = ({ patientUuid }) => {
+  const [encounters, setEncounters] = useState([]);
+
+  useEffect(() => {
+    if (!patientUuid) return;
+    fetchPatientAdmissionRequests(patientUuid);
+  }, [patientUuid]);
+
+  async function fetchPatientAdmissionRequests(patientUuid: string) {
+    const resp = await fetchPatientEncountersByType(patientUuid, 'b2c4d5e6-7f8a-4e9b-8c1d-2e3f8e4a3b8f');
+    setEncounters(resp);
+  }
+
+  if (!patientUuid) {
+    return <>No patient specified</>;
+  }
+
+  const recordAdmissionRequest = () => {};
+
+  return (
+    <>
+      <div className={styles.admissionLayout}>
+        <div className={styles.actionSection}>
+          <Button kind="primary" onClick={recordAdmissionRequest} size="sm">
+            + Record Admission Request
+          </Button>
+        </div>
+        <div className={styles.contentSection}>
+          <Table aria-label="sample table" size="lg">
+            <TableHead>
+              <TableRow>
+                <TableHeader>No</TableHeader>
+                <TableHeader>Form</TableHeader>
+                <TableHeader>Encounter</TableHeader>
+                <TableHeader>Date</TableHeader>
+                <TableHeader>Location</TableHeader>
+              </TableRow>
+            </TableHead>
+            <TableBody>
+              {encounters ? (
+                encounters.map((encounter, index) => {
+                  return (
+                    <TableRow>
+                      <TableCell>{index + 1}</TableCell>
+                      <TableCell>{encounter.form.display}</TableCell>
+                      <TableCell>{encounter.display}</TableCell>
+                      <TableCell>{formatDate(parseDate(encounter.encounterDatetime))}</TableCell>
+                      <TableCell>{encounter.location.display}</TableCell>
+                    </TableRow>
+                  );
+                })
+              ) : (
+                <></>
+              )}
+            </TableBody>
+          </Table>
+        </div>
+      </div>
+    </>
+  );
+};
+
+export default PatientAdmisssionRequests;

package/src/admissions/inpatient/inpatient-admissions.component.scss

@@ -0,0 +1,7 @@
+.admissionsLayout{
+    display: flex;
+    flex-direction: column;
+    row-gap: 15px;
+    width: 100%;
+    padding: 10px 10px;
+}

package/src/admissions/inpatient/inpatient-admissions.component.tsx

@@ -0,0 +1,46 @@
+import React from 'react';
+import { Tab, TabList, TabPanel, TabPanels, Tabs } from '@carbon/react';
+import styles from './inpatient-admissions.component.scss';
+import { usePatient } from '@openmrs/esm-framework';
+import PatientAdmisssionRequests from './admission-requests/patient-admission-requests';
+import PatientAdmissionHistory from './admission-history/patient-admission-history';
+interface InpatientAdmissionsProps {}
+const InpatientAdmissions: React.FC<InpatientAdmissionsProps> = () => {
+  const { isLoading, error, patient } = usePatient();
+  if (isLoading) return <div>Loading…</div>;
+  if (error) return <div>Error loading patient</div>;
+  return (
+    <>
+      <div className={styles.admissionsLayout}>
+        <Tabs onTabCloseRequest={function rTe() {}}>
+          <TabList scrollDebounceWait={200}>
+            <Tab>Admission Requests</Tab>
+            <Tab>Inpatient History</Tab>
+          </TabList>
+          <TabPanels>
+            <TabPanel>
+              {patient ? (
+                <>
+                  <PatientAdmisssionRequests patientUuid={patient.id} />
+                </>
+              ) : (
+                <></>
+              )}
+            </TabPanel>
+            <TabPanel>
+              {patient ? (
+                <>
+                  <PatientAdmissionHistory patientUuid={patient.id} />
+                </>
+              ) : (
+                <></>
+              )}
+            </TabPanel>
+          </TabPanels>
+        </Tabs>
+      </div>
+    </>
+  );
+};
+
+export default InpatientAdmissions;

package/src/admissions/modal/admit-elsewhere/admit-elsewhere.modal.scss

@@ -0,0 +1,23 @@
+.admitModalLayout{
+    display: flex;
+    flex-direction: column;
+    row-gap: 15px;
+    width: 100%;
+}
+.admitModalContentSection{
+    display: flex;
+    flex-direction: column;
+    row-gap: 15px;
+    width: 100%;
+}
+
+.locationSelect{
+    width: 100%;
+}
+
+.formRow{
+   display: flex;
+   flex-direction: row;
+   width: 100%;
+   column-gap: 5px;
+}