@ampath/esm-dha-workflow-app 4.0.0-next.33 → 4.0.0-next.331

package/src/admissions/bed-assigment-request/bed-assignment-request-list.tsx

@@ -0,0 +1,134 @@
+import React, { useEffect, useState } from 'react';
+import {
+  OverflowMenu,
+  OverflowMenuItem,
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@carbon/react';
+import { FacilityAdmissionRequest, type AdmittedListData, type BedLayout } from '../types';
+import BedSwapModal from '../modal/bed-swap/bed-swap.modal';
+import { launchWorkspace2, useConfig } from '@openmrs/esm-framework';
+import { type ConfigObject } from '../../config-schema';
+import { fetchAdmittedPatients, getPatientByUuid } from '../admissions.resource';
+
+interface AdmittedListProps {
+  locationUuid: string;
+  refresh: () => void;
+}
+
+const BedAssignmentRequestList: React.FC<AdmittedListProps> = ({ locationUuid, refresh }) => {
+  const [showBedSwapModal, setShowBedSwapModal] = useState<boolean>(false);
+  const [selectedLayout, setSelectedLayout] = useState<any>();
+  const { maternityDischargeFormUuid } = useConfig<ConfigObject>();
+  const [admittedPatients, setAdmittedPatients] = useState<AdmittedListData[]>([]);
+
+  useEffect(() => {
+    if (locationUuid) {
+      getAdmittedPatientList();
+    }
+  }, [locationUuid]);
+  async function getAdmittedPatientList() {
+    const resp = await fetchAdmittedPatients(locationUuid);
+    if (resp) {
+      const unAssignedBeds = resp.filter((l) => {
+        return !l.bed_id;
+      });
+      setAdmittedPatients(unAssignedBeds);
+    } else {
+      setAdmittedPatients([]);
+    }
+  }
+  const handleTransferRequest = (layout: BedLayout) => {
+    setSelectedLayout(layout);
+  };
+  const handleBedSwapRequest = (layout: BedLayout) => {
+    setSelectedLayout(layout);
+    setShowBedSwapModal(true);
+  };
+  const handleDischargeRequest = async (layout: any) => {
+    setSelectedLayout(layout);
+
+    if (!layout) {
+      console.error('Layout is null');
+      return;
+    }
+
+    const patientUuid = layout.patientUuid || layout.uuid;
+    if (!patientUuid) {
+      console.error('No patientUuid', layout);
+      return;
+    }
+
+    try {
+      const patientData = await getPatientByUuid(patientUuid);
+
+      await launchWorkspace2(
+        'admissions-form-entry',
+        {
+          workspaceTitle: 'Maternity Discharge Form',
+          formUuid: maternityDischargeFormUuid,
+          patientUuid,
+        },
+        {
+          patient: patientData,
+          patientUuid,
+        },
+      );
+    } catch (error) {
+      console.error('Failed to fetch patient data:', error);
+    }
+  };
+  const handleBedSwapModalClose = () => {
+    setShowBedSwapModal(false);
+    refresh();
+  };
+
+  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>
+          {admittedPatients.map((row, index) => (
+            <TableRow key={index}>
+              <TableCell>{index + 1}</TableCell>
+              <TableCell>{row.bed_number}</TableCell>
+              <TableCell>{row.patient_name}</TableCell>
+              <TableCell>{row.gender}</TableCell>
+              <TableCell>{row.age}</TableCell>
+              <TableCell>
+                {row.cr_id},{row.national_id}
+              </TableCell>
+              <TableCell>{row.bed_status}</TableCell>
+              <TableCell>{row.location}</TableCell>
+              <TableCell>
+                <>
+                  <OverflowMenu aria-label="overflow-menu">
+                    <OverflowMenuItem itemText="Bed Swap" onClick={() => handleBedSwapRequest(row as any)} />
+                  </OverflowMenu>
+                </>
+              </TableCell>
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+    </>
+  );
+};
+
+export default BedAssignmentRequestList;

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,67 @@
+import { Link, 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>
+                    {val.subject.reference ? (
+                      <Link href={`${window.spaBase}/patient/${val.subject.reference.split('/').pop()}/chart/`}>
+                        {getPatientName(val.subject.display ?? '')}
+                      </Link>
+                    ) : (
+                      getPatientName(val.subject.display ?? '')
+                    )}
+                  </TableCell>
+                  <TableCell>{getPatientIdentifier(val.subject.display ?? '')}</TableCell>
+                </TableRow>
+              </>
+            );
+          })}
+        </TableBody>
+      </Table>
+    </>
+  );
+};
+export default DischargedList;

package/src/admissions/form-entry-workspace/form-entry-workspace.tsx

@@ -0,0 +1,62 @@
+import React, { useState, useMemo } from 'react';
+import { ExtensionSlot, Workspace2, usePatient } from '@openmrs/esm-framework';
+import { useSWRConfig } from 'swr';
+import { invalidateVisitAndEncounterData } from '@openmrs/esm-patient-common-lib';
+
+export interface ClinicalFormWorkspaceProps {
+  workspaceTitle: string;
+  formUuid: string;
+  patientUuid: string;
+  visitUuid?: string;
+  visitTypeUuid?: string;
+  encounterUuid?: string;
+  handlePostResponse?: (encounter: any) => void;
+}
+
+export default function FormEntryWorkspace({
+  closeWorkspace,
+  workspaceProps,
+}: any) {
+  const { workspaceTitle, formUuid, patientUuid, visitUuid, visitTypeUuid, encounterUuid, handlePostResponse } = workspaceProps;
+  const { mutate: globalMutate } = useSWRConfig();
+  const [hasUnsavedChanges, setHasUnsavedChanges] = useState(false);
+  const { patient, isLoading } = usePatient(patientUuid);
+
+    const formState = useMemo(
+    () => ({
+      view: 'form',
+      formUuid,
+      patientUuid,
+      patient,
+      visitUuid: visitUuid ?? '',
+      visitTypeUuid: visitTypeUuid ?? '',
+      encounterUuid: encounterUuid ?? '',
+      visit: null,
+      closeWorkspace,
+      closeWorkspaceWithSavedChanges: () => {
+        invalidateVisitAndEncounterData(globalMutate, patientUuid);
+        return closeWorkspace({ discardUnsavedChanges: true });
+      },
+      handlePostResponse,
+      hideControls: false,
+      hidePatientBanner: false,
+      setHasUnsavedChanges,
+      promptBeforeClosing: (func) => setHasUnsavedChanges(func()),
+    }),
+    [formUuid, patientUuid, patient, visitUuid, visitTypeUuid, encounterUuid, closeWorkspace, globalMutate, handlePostResponse],
+  );
+  
+  if (!formUuid || !patientUuid || !closeWorkspace) {
+    return <div>Loading workspace...</div>;
+  }
+
+  if (isLoading) {
+    return <div>Loading patient...</div>;
+  }
+
+  return (
+    <Workspace2 title={workspaceTitle} hasUnsavedChanges={hasUnsavedChanges}>
+      <ExtensionSlot name="form-widget-slot" state={formState} />
+    </Workspace2>
+  );
+}

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/add-bill-items/add-bill-items.modal.scss

@@ -0,0 +1,17 @@
+.addBillItemsModalLayout{
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    row-gap: 10px;
+    .formRow{
+        display: flex;
+        flex-direction: row;
+        width: 100%;
+        column-gap: 5px;
+        .inputWidth{
+            display: flex;
+            flex-direction: column;
+            width: 30%;
+        }
+    }
+}