@ampath/esm-dha-workflow-app 4.0.0-claim-workflows.159

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;
+}

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

@@ -0,0 +1,156 @@
+import { ComboBox, Modal, ModalBody, Select, SelectItem, TextArea } from "@carbon/react";
+import React, { useMemo, useRef, useState } from "react";
+import styles from './admit-elsewhere.modal.scss'
+import { Location, Patient, showSnackbar, useLocations, useSession, Visit } from "@openmrs/esm-framework";
+import { AdmitPatientDto } from "../../types";
+import { AdmissionConcepts, AdmissionEncounterTypeUuids } from "../../constants";
+import { admitPatientElseWhere } from "../../admissions.resource";
+interface AdmitElsewhereModalProps {
+    open: boolean;
+    patient: Patient;
+    visit: Visit;
+    onModalClose: () => void;
+    onSuccessfullTransfer: () => void;
+}
+const AdmitElsewhereModal: React.FC<AdmitElsewhereModalProps> = ({ open, onModalClose, onSuccessfullTransfer, patient, visit }) => {
+    const [transferLocation, setTransferLocation] = useState<string>();
+    const locations = useLocations();
+    const session = useSession();
+    const userLocation = session.sessionLocation;
+    const reasonRef = useRef<string>();
+    const locationsOptions = useMemo(() => generateLocationOption(), [locations]);
+    function generateLocationOption() {
+        return locations.filter((l)=>{
+            if(!userLocation){
+             return true;
+            }else{
+                return l.uuid !== userLocation.uuid;
+            }
+        }).map((l: Location) => {
+            return {
+                id: l.uuid,
+                text: l.display,
+            };
+        });
+    }
+    const handleTransfer = async () => {
+        if(!validateTransferPayload()){
+            return;
+        }
+        try {
+            const transferPatientDto = generateAdmitPatientPayload();
+            await admitPatientElseWhere(transferPatientDto);
+            showSnackbar({
+                kind: 'success',
+                title: 'Transfer Request Successful',
+                subtitle: 'Patient Transfer Request was Successful',
+            });
+            onSuccessfullTransfer();
+        } catch (error) {
+            console.log({ error });
+            showSnackbar({
+                kind: 'error',
+                title: 'Transfer Request failed',
+                subtitle: error.message ?? 'Patient Transfer Request failed'
+            });
+        }
+
+    };
+    const validateTransferPayload = ():boolean=>{
+     if(!transferLocation){
+        showSnackbar({
+            kind: 'error',
+            title: 'Transfer Location missing',
+            subtitle: 'Please select the location to transfer patient'
+        });
+        return false;
+     }
+     if(!reasonRef.current){
+        showSnackbar({
+            kind: 'error',
+            title: 'Missing Transfer reason',
+            subtitle: 'Please enter the transfer reason'
+        });
+        return false;
+     }
+     return true;
+    };
+    const generateAdmitPatientPayload = (): AdmitPatientDto => {
+        return {
+            patient: patient.uuid,
+            encounterType: {
+                uuid: AdmissionEncounterTypeUuids.TRANSFER_REQUEST_ENCOUNTER_TYPE_UUID
+            },
+            location: userLocation.uuid,
+            obs: [
+                {
+                    "concept": AdmissionConcepts.INPATIENT_DISPOSITION_CONSTRUCT_UUID,
+                    "groupMembers": [
+                        {
+                            "concept": AdmissionConcepts.INTERNAL_TRANSFER_LOCATION_UUID,
+                            "value": transferLocation
+                        },
+                        {
+                            "concept": AdmissionConcepts.INPATIENT_PATIENT_DISPOSITION_UUID,
+                            "value": AdmissionConcepts.TRANSFER_OUT_UUID
+                        },
+                        {
+                            "concept": AdmissionConcepts.CLINICAL_NOTES_UUID,
+                            "value": reasonRef.current
+                        }
+                    ]
+                }
+            ],
+            visit: visit.uuid
+        }
+    }
+    const handleReasonText = (reason: string) => {
+        reasonRef.current = reason;
+    };
+    const locationChangeHandler = (location: { selectedItem: { id: string; text: string } }) => {
+        const l = location.selectedItem.id;
+        setTransferLocation(l);
+    };
+    return <>
+        <Modal
+            modalHeading="Transfer Elsewhere"
+            open={open}
+            size="md"
+            onSecondarySubmit={() => onModalClose()}
+            onRequestClose={() => onModalClose()}
+            onRequestSubmit={handleTransfer}
+            primaryButtonText="Send Admission Request"
+            secondaryButtonText="Cancel"
+        >
+            <ModalBody>
+                <div className={styles.admitModalLayout}>
+                    <div className={styles.admitModalContentSection}>
+                        <div className={styles.formRow}>
+                            <ComboBox
+                                onChange={locationChangeHandler}
+                                id="visit-type-combobox"
+                                items={locationsOptions}
+                                itemToString={(item) => (item ? item.text : '')}
+                                titleText="Select Transfer Location"
+                                className={styles.locationSelect}
+                            />
+                        </div>
+                        <div className={styles.formRow}>
+                            <TextArea
+                                enableCounter
+                                helperText=""
+                                id="transfer-reason"
+                                labelText="Transfer Reason"
+                                maxCount={500}
+                                placeholder=""
+                                rows={4}
+                                onChange={(e) => handleReasonText(e.target.value)}
+                            />
+                        </div>
+                    </div>
+                </div>
+            </ModalBody>
+        </Modal>
+    </>
+}
+export default AdmitElsewhereModal;