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

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

@@ -0,0 +1,109 @@
+import React, { useState } from "react";
+import { AdmitPatientDto, AssignBedToPatientDto, BedLayout, Disposition } from "../../types";
+import { Modal, ModalBody, Select, SelectItem } from "@carbon/react";
+import { Encounter, Patient, showSnackbar, useSession } from "@openmrs/esm-framework";
+import styles from './admit-patient.modal.scss';
+import { AdmissionEncounterTypeUuids } from "../../constants";
+import { admitPatientToWard, assignBedToPatient } from "../../admissions.resource";
+interface AdmitPatientModalProps {
+    open: boolean;
+    disposition: Disposition;
+    onModalClose: () => void;
+    bedLayouts: BedLayout[];
+    onSuccessfullAdmission: () => void;
+}
+const AdmitPatientModal: React.FC<AdmitPatientModalProps> = ({ onModalClose, open, disposition, bedLayouts, onSuccessfullAdmission }) => {
+    const [selectedBedId, setSelectedBedId] = useState<number>();
+    const session = useSession();
+    const location = session.sessionLocation;
+
+    const admitPatient = async () => {
+        try{
+            const admitPatientDto = generateAdmitPatientPayload();
+            const resp = await admitPatientToWard(admitPatientDto);
+
+            showSnackbar({
+                kind: 'success',
+                title: 'Admission Successfull',
+                subtitle: 'Patient Successfully Admitted',
+            });
+    
+            //assign bed to patient
+            const assignBedDto = generateAssignBedPayload(resp);
+            await assignBedToPatient(selectedBedId,assignBedDto);
+
+            showSnackbar({
+                kind: 'success',
+                title: 'Bed Assignment Successfull',
+                subtitle: `Patient Successfully assigned bed ${selectedBedId}`,
+            });
+
+            onSuccessfullAdmission();
+            
+        }catch(error){
+            console.log({error});
+            showSnackbar({
+                kind: 'error',
+                title: 'Bed Assignment failed',
+                subtitle: error.message ?? 'Bed Assignment failed'
+            });
+
+        }
+       
+    };
+    const bedSelectedHandler = (bedId: number) => {
+        setSelectedBedId(bedId);
+    };
+    const generateAdmitPatientPayload = (): AdmitPatientDto=>{
+      return {
+        patient: disposition.patient.uuid,
+        encounterType: {
+            uuid: AdmissionEncounterTypeUuids.ADMIT_ENCOUNTER_TYPE_UUID
+        },
+        location: location.uuid,
+        obs: [],
+        visit: disposition.visit.uuid
+      }
+    }
+    const generateAssignBedPayload = (admissionEncounter: Encounter): AssignBedToPatientDto=>{
+        return {
+            patientUuid: disposition.patient.uuid,
+            encounterUuid: admissionEncounter.uuid
+        }
+    }
+    return <>
+        <Modal
+            modalHeading="Admit Patient"
+            open={open}
+            size="md"
+            onSecondarySubmit={() => onModalClose()}
+            onRequestClose={() => onModalClose()}
+            onRequestSubmit={admitPatient}
+            primaryButtonText="Admit"
+            secondaryButtonText="Cancel"
+        >
+            <ModalBody>
+                <div className={styles.serveModalLayout}>
+                    <div className={styles.serveModalContentSection}>
+                        <div className={styles.formRow}>
+                            <Select
+                                id="ward-beds"
+                                labelText="Beds"
+                                onChange={($event) => bedSelectedHandler(parseInt($event.target.value))}
+                            >
+                                <SelectItem value="" text="Select" />;
+                                {bedLayouts &&
+                                    bedLayouts.filter((bl)=>{
+                                        return bl.status === 'AVAILABLE'
+                                    }).map((bl) => {
+                                        return <SelectItem value={bl.bedId} text={`${bl.bedNumber} (${bl.status})`} />;
+                                    })}
+                            </Select>
+                        </div>
+                    </div>
+                </div>
+            </ModalBody>
+        </Modal>
+    </>
+}
+export default AdmitPatientModal;

package/src/admissions/modal/bed-swap/bed-swap.modal.tsx

@@ -0,0 +1,102 @@
+import { Modal, ModalBody, Select, SelectItem } from "@carbon/react";
+import React, { useState } from "react";
+import { AssignBedToPatientDto, BedLayout, BedSwapDto, Disposition } from "../../types";
+import styles from './bed-swap.modal.scss';
+import { AdmissionEncounterTypeUuids } from "../../constants";
+import { Encounter,Person, showSnackbar, useSession } from "@openmrs/esm-framework";
+import { assignBedToPatient, bedSwapRequest } from "../../admissions.resource";
+interface BedSwapModalProps {
+    open: boolean;
+    disposition: Disposition;
+    person: Person;
+    onModalClose: () => void;
+    bedLayouts: BedLayout[];
+    onSuccessfullBedSwap: () => void;
+}
+const BedSwapModal: React.FC<BedSwapModalProps> = ({open,onModalClose,onSuccessfullBedSwap,bedLayouts,disposition,person})=>{
+    const [selectedBedId, setSelectedBedId] = useState<number>();
+    const session = useSession();
+    const location = session.sessionLocation;
+    
+    const swapBed = async ()=>{
+
+        try{
+            const bedSwapPayload = generateBedSwapRequestDto();
+            const resp = await bedSwapRequest(bedSwapPayload);
+
+              //assign bed to patient
+            const assignBedDto = generateAssignBedPayload(resp);
+            await assignBedToPatient(selectedBedId,assignBedDto);
+            showSnackbar({
+                kind: 'success',
+                title: 'Bed swap Successfull',
+                subtitle: `Patient Successfully assigned bed ${selectedBedId}`,
+            });
+            onSuccessfullBedSwap();
+        }catch(error){
+            console.log({error});
+            showSnackbar({
+                kind: 'error',
+                title: 'Bed Assignment failed',
+                subtitle: error.message ?? 'Bed Assignment failed'
+            });
+        }
+      
+
+    }
+    const generateAssignBedPayload = (assignEncounter: Encounter): AssignBedToPatientDto=>{
+        return {
+            patientUuid: person.uuid,
+            encounterUuid: assignEncounter.uuid
+        }
+    }
+    const handleBedChange = (bedId: number)=>{
+        setSelectedBedId(bedId);
+    }
+    const generateBedSwapRequestDto = (): BedSwapDto => {
+        return {
+            "patient": person.uuid,
+            "encounterType": {
+                "uuid": AdmissionEncounterTypeUuids.BED_ASSIGNMENT_ENCOUNTER_TYPE_UUID,
+            },
+            "location": location.uuid,
+            "obs": [],
+        }
+    }
+
+    return <>
+     <Modal
+            modalHeading="Swap Beds"
+            open={open}
+            size="md"
+            onSecondarySubmit={() => onModalClose()}
+            onRequestClose={() => onModalClose()}
+            onRequestSubmit={swapBed}
+            primaryButtonText="Swap Beds"
+            secondaryButtonText="Cancel"
+        >
+            <ModalBody>
+                <div className={styles.serveModalLayout}>
+                    <div className={styles.serveModalContentSection}>
+                        <div className={styles.formRow}>
+                            <Select
+                                id="ward-beds"
+                                labelText="Beds"
+                                onChange={($event) => handleBedChange(parseInt($event.target.value))}
+                            >
+                                <SelectItem value="" text="Select" />;
+                                {bedLayouts &&
+                                    bedLayouts.filter((bl)=>{
+                                        return bl.status === 'AVAILABLE'
+                                    }).map((bl) => {
+                                        return <SelectItem value={bl.bedId} text={`${bl.bedNumber} (${bl.status})`} />;
+                                    })}
+                            </Select>
+                        </div>
+                    </div>
+                </div>
+            </ModalBody>
+        </Modal>
+    </>
+}
+export default BedSwapModal;

package/src/admissions/modal/cancel-admission-request/cancel-admission-request.scss

@@ -0,0 +1,11 @@
+.cancelAdmissionLayout{
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    row-gap: 15px;
+}
+.headerSection{
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+}

package/src/admissions/modal/cancel-admission-request/cancel-admission-request.tsx

@@ -0,0 +1,105 @@
+import React, { useRef } from 'react';
+import styles from './cancel-admission-request.scss';
+import { Modal, ModalBody, TextArea } from '@carbon/react';
+import { type CancelAdmissionDto, type Disposition } from '../../types';
+import { showSnackbar, useSession } from '@openmrs/esm-framework';
+import { AdmissionConcepts, AdmissionEncounterTypeUuids } from '../../constants';
+import { cancelAdmissionRequest } from '../../admissions.resource';
+
+interface CancelAdmissionRequestModalProps {
+  open: boolean;
+  admissionRequest: Disposition;
+  onModalClose: () => void;
+  onCancelAdmission: () => void;
+}
+const CancelAdmissionRequestModal: React.FC<CancelAdmissionRequestModalProps> = ({
+  open,
+  admissionRequest,
+  onCancelAdmission,
+  onModalClose,
+}) => {
+  const reasonRef = useRef<string>();
+  const session = useSession();
+  const location = session.sessionLocation;
+  const handleReasonText = (reason: string) => {
+    reasonRef.current = reason;
+  };
+  const handleCancelRequest = async () => {
+    try {
+      const cancelAdmissionDto = generateCancelAdmissionRequestDto();
+      const resp = await cancelAdmissionRequest(cancelAdmissionDto);
+      if (resp) {
+        showSnackbar({
+          kind: 'success',
+          title: 'Cancel request successfull',
+          subtitle: 'Admission request succesfully cancelled',
+        });
+      }
+      onCancelAdmission();
+    } catch (error) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Bed Assignment failed',
+        subtitle: error.message ?? 'Bed Assignment failed',
+      });
+    }
+  };
+  const generateCancelAdmissionRequestDto = (): CancelAdmissionDto => {
+    return {
+      patient: admissionRequest.patient.uuid,
+      encounterType: {
+        uuid: AdmissionEncounterTypeUuids.CANCEL_ADT_ENCOUNTER_TYPE_UUID,
+      },
+      location: location.uuid,
+      obs: [
+        {
+          concept: AdmissionConcepts.CLINICAL_NOTES_UUID,
+          value: reasonRef.current,
+        },
+        {
+          concept: AdmissionConcepts.ADMISSION_TO_HOSPITAL_DECISION_UUID,
+          value: {
+            uuid: AdmissionConcepts.ADMISSION_DENIED_UUID,
+          },
+        },
+      ],
+      visit: admissionRequest.visit.uuid,
+    };
+  };
+
+  return (
+    <>
+      <Modal
+        modalHeading="Cancel Admission Request"
+        open={open}
+        size="md"
+        onSecondarySubmit={onModalClose}
+        onRequestClose={onModalClose}
+        onRequestSubmit={handleCancelRequest}
+        primaryButtonText="Cancel Admission Request"
+        secondaryButtonText="Cancel"
+      >
+        <ModalBody>
+          <div className={styles.cancelAdmissionLayout}>
+            <div className={styles.contentSection}>
+              <div className={styles.formRow}>
+                <TextArea
+                  enableCounter
+                  helperText=""
+                  id="cancel-reason"
+                  labelText="Cancel Reason"
+                  maxCount={500}
+                  placeholder=""
+                  rows={4}
+                  onChange={(e) => handleReasonText(e.target.value)}
+                />
+              </div>
+            </div>
+          </div>
+        </ModalBody>
+      </Modal>
+    </>
+  );
+};
+
+export default CancelAdmissionRequestModal;

package/src/admissions/modal/discharge/discharge-patient.modal.scss

@@ -0,0 +1,13 @@
+.dischargeLayout{
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    row-gap: 15px;
+}
+.contentSection{
+    display: flex;
+    flex-direction: row;
+    width: 100%;
+    justify-content: center;
+    align-items: center;
+}

package/src/admissions/modal/discharge/discharge-patient.modal.tsx

@@ -0,0 +1,84 @@
+import React from 'react';
+import { type DischargePatientDto, type Disposition, type UnAssignBedDto } from '../../types';
+import { Modal, ModalBody } from '@carbon/react';
+import styles from './discharge-patient.modal.scss';
+import { AdmissionEncounterTypeUuids } from '../../constants';
+import { type Person, showSnackbar, useSession } from '@openmrs/esm-framework';
+import { dischargePatientFromWard, unassignBed } from '../../admissions.resource';
+interface DischargeModalProps {
+  open: boolean;
+  admissionRequest: Disposition & { bedId: number; person: Person };
+  onModalClose: () => void;
+  onDischarge: () => void;
+}
+const DischargeModal: React.FC<DischargeModalProps> = ({ open, admissionRequest, onModalClose, onDischarge }) => {
+  const session = useSession();
+  const location = session.sessionLocation;
+  const handleDischarge = async () => {
+    try {
+      const dischargeDto = generateDischargePatientRequestDto();
+      await dischargePatientFromWard(dischargeDto);
+      showSnackbar({
+        kind: 'success',
+        title: 'Discharge request successfull',
+        subtitle: 'Patient Succesfully discharged from ward',
+      });
+
+      // unassign bed
+      const unAssignBedDto = generateUnassignBedDto();
+      await unassignBed(unAssignBedDto);
+
+      showSnackbar({
+        kind: 'success',
+        title: 'Bed Unassigned successfull',
+        subtitle: `Bed ${admissionRequest.bedId} successfully unassigned`,
+      });
+      onDischarge();
+    } catch (error) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Patient Discharge failed',
+        subtitle: 'Patient Discharge failed',
+      });
+    }
+  };
+  const generateDischargePatientRequestDto = (): DischargePatientDto => {
+    return {
+      patient: admissionRequest.person.uuid,
+      encounterType: {
+        uuid: AdmissionEncounterTypeUuids.DISCHARGE_ENCOUNTER_TYPE_UUID,
+      },
+      location: location.uuid,
+      obs: [],
+    };
+  };
+  const generateUnassignBedDto = (): UnAssignBedDto => {
+    return {
+      patientUuid: admissionRequest.person.uuid,
+      bedId: admissionRequest.bedId,
+    };
+  };
+  return (
+    <>
+      <Modal
+        modalHeading="Discharge"
+        open={open}
+        size="md"
+        onSecondarySubmit={onModalClose}
+        onRequestClose={onModalClose}
+        onRequestSubmit={handleDischarge}
+        primaryButtonText="Discharge"
+        secondaryButtonText="Cancel"
+      >
+        <ModalBody>
+          <div className={styles.dischargeLayout}>
+            <div className={styles.contentSection}>
+              <h5>Are you sure you want to discharge Patient from Ward?</h5>
+            </div>
+          </div>
+        </ModalBody>
+      </Modal>
+    </>
+  );
+};
+export default DischargeModal;

package/src/admissions/types/index.ts

@@ -0,0 +1,192 @@
+import { Concept, Encounter, Obs, Patient, Visit, type Location } from "@openmrs/esm-framework";
+
+export type DispositionType = 'ADMIT' | 'TRANSFER';
+export type DispositionResponse = {
+  results: Disposition[];
+};
+
+export type Disposition = {
+  dispositionLocation: Location;
+  dispositionType: DispositionType;
+  disposition: Concept;
+  dispositionEncounter: Encounter;
+  patient: Patient;
+  dispositionObsGroup: Obs;
+  visit: Visit;
+}
+
+export interface BedTag {
+  id: number;
+  name: string;
+  uuid: string;
+  resourceVersion: string;
+}
+
+export interface BedTagMap {
+  uuid: string;
+  bedTag: BedTag;
+  resourceVersion: string;
+}
+
+export interface BedType {
+  uuid: string;
+  name: string;
+  displayName: string;
+  description: string;
+  resourceVersion: string;
+}
+
+export type BedStatus = 'OCCUPIED' | 'AVAILABLE';
+
+export interface BedLayout {
+  rowNumber: number;
+  columnNumber: number;
+  bedNumber: string;
+  bedId: number;
+  bedUuid: string;
+  status: BedStatus;
+  location: string;
+  bedType: BedType | null;
+  patients: Patient[];
+  bedTagMaps: BedTagMap[];
+  resourceVersion: string;
+}
+
+export interface AdmissionLocationData {
+  ward: Location;
+  totalBeds: number;
+  occupiedBeds: number;
+  bedLayouts: BedLayout[];
+  resourceVersion: string;
+}
+
+export interface EncounterDto {
+  patient: string;
+  encounterType: {
+    uuid: string;
+  },
+  location: string;
+  obs: any[];
+  visit?: string;
+}
+
+export interface AdmitPatientDto extends EncounterDto{
+}
+export type AssignBedToPatientDto = {
+ patientUuid:string;
+ encounterUuid: string;
+}
+
+export interface CancelAdmissionDto extends EncounterDto{
+}
+
+export interface BedSwapDto extends EncounterDto {
+}
+
+export interface DischargePatientDto extends EncounterDto {
+}
+export interface TransferPatientDto extends EncounterDto {
+}
+export type UnAssignBedDto = {
+  patientUuid: string;
+  bedId: number;
+}
+
+export interface FhirEncounterBundle {
+  resourceType: 'Bundle';
+  id: string;
+  meta: FhirBundleMeta;
+  type: 'searchset';
+  total: number;
+  link: FhirBundleLink[];
+  entry: FhirBundleEntry<FhirEncounter>[];
+}
+
+export interface FhirBundleMeta {
+  lastUpdated: string;
+  tag: FhirMetaTag[];
+}
+
+export interface FhirMetaTag {
+  system: string;
+  code: string;
+  display: string;
+}
+
+export interface FhirBundleLink {
+  relation: string;
+  url: string;
+}
+
+export interface FhirBundleEntry<TResource> {
+  fullUrl: string;
+  resource: TResource;
+}
+
+
+export interface FhirEncounter {
+  resourceType: 'Encounter';
+  id: string;
+  meta: FhirEncounterMeta;
+  status: string;
+  class: FhirEncounterClass;
+  type: FhirEncounterType[];
+  subject: FhirReferenceWithDisplay<'Patient'>;
+  participant: FhirEncounterParticipant[];
+  period: FhirPeriod;
+  location: FhirEncounterLocationComponent[];
+  partOf: FhirReference<'Encounter'>;
+}
+
+export interface FhirEncounterMeta {
+  versionId: string;
+  lastUpdated: string;
+  tag: FhirMetaTag[];
+}
+
+export interface FhirEncounterClass {
+  system: string;
+  code: string;
+}
+
+export interface FhirEncounterType {
+  coding: FhirCoding[];
+}
+
+export interface FhirCoding {
+  system?: string;
+  code?: string;
+  display?: string;
+}
+
+
+export interface FhirEncounterParticipant {
+  individual: FhirParticipantIndividual;
+}
+
+export interface FhirParticipantIndividual {
+  reference: string;
+  type: 'Practitioner';
+  identifier?: {
+    value: string;
+  };
+  display: string;
+}
+
+export interface FhirPeriod {
+  start: string;
+}
+
+export interface FhirEncounterLocationComponent {
+  location: FhirReferenceWithDisplay<'Location'>;
+}
+
+
+export interface FhirReference<TType extends string> {
+  reference: string; // e.g. "Encounter/..."
+  type: TType;
+}
+
+export interface FhirReferenceWithDisplay<TType extends string> extends FhirReference<TType> {
+  display: string;
+}

package/src/appointments/appointments.component.tsx

@@ -0,0 +1,13 @@
+import React, { useEffect, useState } from 'react';
+import { ExtensionSlot, WorkspaceContainer } from '@openmrs/esm-framework';
+
+const AppointmentsComponent: React.FC = () => {
+  
+  return (
+    <div>
+      <ExtensionSlot name="clinical-appointments-dashboard-slot" />
+    </div>
+  );
+};
+
+export default AppointmentsComponent;