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

package/src/service-queues/service-queue/service-queue.component.tsx

@@ -1,7 +1,12 @@
 import React, { useEffect, useMemo, useState } from 'react';
 import { type QueueEntryResult } from '../../registry/types';
 import { showSnackbar, useSession } from '@openmrs/esm-framework';
-import { closeQueueEntry, getServiceQueueByLocationUuid } from '../service-queues.resource';
+import {
+  closeQueueEntry,
+  getServiceQueueByLocationUuid,
+  getServiceQueueDailyPatientListReport,
+  getServiceQueueDailyReport,
+} from '../service-queues.resource';
 import { Button, InlineLoading, Tab, TabList, TabPanel, TabPanels, Tabs } from '@carbon/react';
 import QueueList from '../queue-list/queue-list.component';
 import styles from './service-queue.component.scss';
@@ -12,6 +17,10 @@ import StatDetails from './stats/stat-details/stat-details.component';
 import SignOffEntryModal from '../modals/sign-off/sign-off.modal';
 import { endVisit } from '../../resources/visit.resource';
 import { QUEUE_SERVICE_UUIDS } from '../../shared/constants/concepts';
+import ConfirmModal from '../../shared/ui/confirm-modal/confirm.modal';
+import { type ServiceQueueReportPatientList, type ServiceQueueDailyReport } from '../../shared/types';
+import DailyReportPatientListModal from '../modals/daily-report-patient-list/daily-report-patient-list';
+import FacilityAndWorkerSlot from '../../shared/ui/facility-worker-slot/facility-worker.component-slot.component';
 
 interface ServiceQueueComponentProps {
   serviceTypeUuid: string;
@@ -20,11 +29,18 @@ interface ServiceQueueComponentProps {
 
 const ServiceQueueComponent: React.FC<ServiceQueueComponentProps> = ({ serviceTypeUuid, title }) => {
   const [queueEntries, setQueueEntries] = useState<QueueEntryResult[]>([]);
+  const [queueEntryDailyReport, setQueueEntryDailyReport] = useState<ServiceQueueDailyReport[]>([]);
+  const [queueEntryDailyReportPatientList, setQueueEntryDailyReportPatientList] = useState<
+    ServiceQueueReportPatientList[]
+  >([]);
   const [selectedQueueEntry, setSelectedQueueEntry] = useState<QueueEntryResult>();
   const [displayMoveModal, setDisplayMoveModal] = useState<boolean>(false);
   const [displayTransitionModal, setDisplayTransitionModal] = useState<boolean>(false);
   const [displayServeModal, setDisplayServeModal] = useState<boolean>(false);
   const [displaySignOffModal, setDisplaySignOffModal] = useState<boolean>(false);
+  const [displayConfirmClearQueueModal, setDisplayConfirmClearQueueModal] = useState<boolean>(false);
+  const [queueEntryToClear, setQueueEntryToClear] = useState<QueueEntryResult[]>();
+  const [displayDailyReportPatientListModal, setDisplayDailyReportPatientListModal] = useState<boolean>(false);
   const [loading, setLoading] = useState<boolean>(false);
   const session = useSession();
   const locationUuid = session.sessionLocation.uuid;
@@ -46,14 +62,43 @@ const ServiceQueueComponent: React.FC<ServiceQueueComponentProps> = ({ serviceTy
   const groupedByRoom: { [key: string]: QueueEntryResult[] } = useMemo(() => groupEntriesByRooms(), [queueEntries]);
 
   useEffect(() => {
-    getEntryQueues();
-  }, []);
+    if (serviceTypeUuid && locationUuid) {
+      getEntryQueues();
+      getEntryQueueDailyReport();
+      fetchStatsPatientList();
+    }
+  }, [serviceTypeUuid, locationUuid]);
+
+
 
   const getEntryQueues = async () => {
     setLoading(true);
-    const res = await getServiceQueueByLocationUuid(serviceTypeUuid, locationUuid);
-    setQueueEntries(res);
-    setLoading(false);
+    try {
+      const res = await getServiceQueueByLocationUuid(serviceTypeUuid, locationUuid);
+      setQueueEntries(res);
+      setLoading(false);
+    } catch (error) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Error fetching queue',
+        subtitle: 'An error occurred while fetching the queue. Please reload or contact support',
+      });
+    }
+  };
+
+  const getEntryQueueDailyReport = async () => {
+    setLoading(true);
+    try {
+      const res = await getServiceQueueDailyReport(serviceTypeUuid, locationUuid);
+      setQueueEntryDailyReport(res);
+      setLoading(false);
+    } catch (error) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Error fetching queue daily report',
+        subtitle: 'An error occurred while fetching the queue daily report. Please reload or contact support',
+      });
+    }
   };
 
   if (!groupedByRoom) {
@@ -130,6 +175,72 @@ const ServiceQueueComponent: React.FC<ServiceQueueComponentProps> = ({ serviceTy
       });
     }
   };
+  const handleClearQueue = async (queueEntries: QueueEntryResult[]) => {
+    setQueueEntryToClear(queueEntries);
+    setDisplayConfirmClearQueueModal(true);
+  };
+
+  const clearQueue = async () => {
+    for (let i = 0; i < queueEntryToClear.length; i++) {
+      const queueEntryResult = queueEntries[i];
+      await closeQueue(queueEntryResult);
+    }
+  };
+
+  const closeQueue = async (queueEntryResult: QueueEntryResult) => {
+    try {
+      await closeQueueEntry(queueEntryResult.queue_entry_uuid);
+      await endVisit(queueEntryResult.visit_uuid, {
+        stopDatetime: new Date().toISOString(),
+      });
+      showSnackbar({
+        kind: 'success',
+        title: 'Queue entry successfully closed',
+        subtitle: `Queue entry ${queueEntryResult.queue_id} successfully closed`,
+      });
+    } catch (error) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Queue entry close failrure',
+        subtitle: `Queue entry ${queueEntryResult.queue_id} could not be closed. Please retry of contact support`,
+      });
+    }
+  };
+
+  const handleConfirmClearQueue = () => {
+    setDisplayConfirmClearQueueModal(false);
+    clearQueue();
+    setQueueEntryToClear([]);
+    handleRefresh();
+  };
+
+  const handleCloseConfirmClearQueueModal = () => {
+    setDisplayConfirmClearQueueModal(false);
+    setQueueEntryToClear([]);
+  };
+
+  const fetchStatsPatientList = async () => {
+    try {
+      const resp = await getServiceQueueDailyPatientListReport(serviceTypeUuid, locationUuid);
+      setQueueEntryDailyReportPatientList(resp);
+    } catch (error) {
+      showSnackbar({
+        kind: 'error',
+        title: 'Error fetching patient list',
+        subtitle: 'An error ocuured while fetching the service queue checked in patient list',
+      });
+    }
+  };
+
+  const getStatsPatientList = () => {
+    showDailiyReportPatientListModal();
+  };
+  const handleCloseDailiyReportPatientListModal = () => {
+    setDisplayDailyReportPatientListModal(false);
+  };
+  const showDailiyReportPatientListModal = () => {
+    setDisplayDailyReportPatientListModal(true);
+  };
 
   if (!serviceTypeUuid) {
     return <>No service type defined</>;
@@ -144,7 +255,11 @@ const ServiceQueueComponent: React.FC<ServiceQueueComponentProps> = ({ serviceTy
         <div>
           {queueEntries ? (
             <>
-              <StatDetails queueEntries={queueEntries} />
+              <StatDetails
+                queueEntries={queueEntries}
+                report={queueEntryDailyReport}
+                onStatDetailsRequest={getStatsPatientList}
+              />
             </>
           ) : (
             <></>
@@ -171,6 +286,7 @@ const ServiceQueueComponent: React.FC<ServiceQueueComponentProps> = ({ serviceTy
                     <TabPanel>
                       {
                         <QueueList
+                          queueRoom={key}
                           queueEntries={groupedByRoom[key]}
                           handleMovePatient={handleMovePatient}
                           handleTransitionPatient={handleTransitionPatient}
@@ -178,6 +294,7 @@ const ServiceQueueComponent: React.FC<ServiceQueueComponentProps> = ({ serviceTy
                           handleSignOff={handleSignOff}
                           handleRemovePatient={handleRemovePatient}
                           showComingFromCol={serviceTypeUuid !== QUEUE_SERVICE_UUIDS.TRIAGE_SERVICE_UUID}
+                          handleClearQueue={handleClearQueue}
                         />
                       }
                     </TabPanel>
@@ -192,9 +309,9 @@ const ServiceQueueComponent: React.FC<ServiceQueueComponentProps> = ({ serviceTy
           <MovePatientModal
             open={displayMoveModal}
             locationUuid={locationUuid}
-            serviceUuid={serviceTypeUuid}
             onModalClose={handleModalCloes}
             currentQueueEntryUuid={selectedQueueEntry.queue_entry_uuid}
+            onTransferSuccess={handleModalCloes}
           />
         </>
       ) : (
@@ -238,6 +355,32 @@ const ServiceQueueComponent: React.FC<ServiceQueueComponentProps> = ({ serviceTy
       ) : (
         <></>
       )}
+
+      {displayConfirmClearQueueModal ? (
+        <>
+          <ConfirmModal
+            open={displayConfirmClearQueueModal}
+            onConfirm={handleConfirmClearQueue}
+            onModalClose={handleCloseConfirmClearQueueModal}
+            title="Clear Queue"
+            subtitle="You are about to clear the patient queue and their respective visits. Are you sure?"
+          />
+        </>
+      ) : (
+        <></>
+      )}
+
+      {displayDailyReportPatientListModal && queueEntryDailyReportPatientList ? (
+        <>
+          <DailyReportPatientListModal
+            open={displayDailyReportPatientListModal}
+            onModalClose={handleCloseDailiyReportPatientListModal}
+            patientList={queueEntryDailyReportPatientList}
+          />
+        </>
+      ) : (
+        <></>
+      )}
     </>
   );
 };

package/src/service-queues/service-queue/stats/stat-details/stat-details.component.scss

@@ -4,4 +4,9 @@
     width: 100%;
     column-gap: 15px;
     margin-bottom: 15px;
+    .aggregate{
+        display: flex;
+        flex-direction: column;
+        width: 50%;
+    }
 }

package/src/service-queues/service-queue/stats/stat-details/stat-details.component.tsx

@@ -1,17 +1,25 @@
-import React from 'react';
+import React, { useMemo } from 'react';
 import styles from './stat-details.component.scss';
 import { type QueueEntryResult } from '../../../../registry/types';
-import StatCard from '../stat-card/stat-card.component';
+import StatCard from '../../../../shared/ui/stat-card/stat-card.component';
+import { type ServiceQueueDailyReport } from '../../../../shared/types';
+import AgregateStatCard from '../../../../shared/ui/aggregate-stat-card/aggregate-stat-card';
 
 interface StatDetailsProps {
   queueEntries: QueueEntryResult[];
+  report: ServiceQueueDailyReport[];
+  onStatDetailsRequest: () => void;
 }
 
-const StatDetails: React.FC<StatDetailsProps> = ({ queueEntries }) => {
+const StatDetails: React.FC<StatDetailsProps> = ({ queueEntries, report, onStatDetailsRequest }) => {
+  const patientsInWaiting = useMemo(() => getCategoryTotal(['WAITING']), [queueEntries]);
+  const patientsAttendedTo = useMemo(() => getCategoryTotal(['IN SERVICE', 'COMPLETED']), [queueEntries]);
+  const patientsCheckedIn = useMemo(() => getTotalCheckedIn(), [report]);
+  const aggregateStats = useMemo(() => getAggregateStats(), [report]);
   if (!queueEntries) {
     return 'No queue entry records';
   }
-  const getCategoryTotal = (categories: string[]) => {
+  function getCategoryTotal(categories: string[]) {
     let total = 0;
     queueEntries.forEach((q) => {
       if (categories.includes(q.status)) {
@@ -19,12 +27,33 @@ const StatDetails: React.FC<StatDetailsProps> = ({ queueEntries }) => {
       }
     });
     return total;
-  };
-  const patientsInWaiting = getCategoryTotal(['WAITING']);
-  const patientsAttendedTo = getCategoryTotal(['IN SERVICE', 'COMPLETED']);
+  }
+  function getTotalCheckedIn() {
+    let total = 0;
+    report.forEach((r) => {
+      total += r.patients;
+    });
+    return total;
+  }
+  function getAggregateStats() {
+    return report.map((r) => {
+      return {
+        title: r.queue_room_name,
+        count: r.patients,
+      };
+    });
+  }
 
   return (
     <div className={styles.statsSection}>
+      <div className={styles.aggregate}>
+        <AgregateStatCard
+          title="Total Checked In"
+          totalCount={patientsCheckedIn ?? 0}
+          stats={aggregateStats}
+          onStatDetailsRequest={onStatDetailsRequest}
+        />
+      </div>
       <StatCard title="Patients in waiting" count={patientsInWaiting ?? 0} />
       <StatCard title="Patients attended to" count={patientsAttendedTo ?? 0} />
     </div>

package/src/service-queues/service-queue.tsx

@@ -9,23 +9,29 @@ interface ServiceQueueProps {
 }
 const ServiceQueue: React.FC<ServiceQueueProps> = ({ isTriage }) => {
   const roomParams = useMemo(() => {
-    return isTriage ? {
-      serviceUuid: 'triage-service-uuid',
-      overflowMenuKeys: ['call', 'transition', 'edit', 'remove', 'undo'] as QueueEntryAction[],
-      defaultMenuKey: 'call' as QueueEntryAction
-    } : {
-      serviceUuid: '7f7ec7ad-cdd7-4ed9-bc2e-5c5bd9f065b2',
-      overflowMenuKeys: ['move', 'transition', 'signOff', 'edit', 'remove', 'undo'] as QueueEntryAction[],
-      defaultMenuKey: 'move' as QueueEntryAction
-    };
-  }
-    , [isTriage]);
+    return isTriage
+      ? {
+          serviceUuid: 'triage-service-uuid',
+          overflowMenuKeys: ['call', 'transition', 'edit', 'remove', 'undo'] as QueueEntryAction[],
+          defaultMenuKey: 'call' as QueueEntryAction,
+        }
+      : {
+          serviceUuid: '7f7ec7ad-cdd7-4ed9-bc2e-5c5bd9f065b2',
+          overflowMenuKeys: ['move', 'transition', 'signOff', 'edit', 'remove', 'undo'] as QueueEntryAction[],
+          defaultMenuKey: 'move' as QueueEntryAction,
+        };
+  }, [isTriage]);
 
-  return (<>
-    <MetricsContainer />
-    <QueueRoom serviceUuid={roomParams.serviceUuid} overflowMenuKeys={roomParams.overflowMenuKeys} defaultMenuKey={roomParams.defaultMenuKey}/>
-  </>
+  return (
+    <>
+      <MetricsContainer />
+      <QueueRoom
+        serviceUuid={roomParams.serviceUuid}
+        overflowMenuKeys={roomParams.overflowMenuKeys}
+        defaultMenuKey={roomParams.defaultMenuKey}
+      />
+    </>
   );
 };
 
-export default ServiceQueue;
+export default ServiceQueue;

package/src/service-queues/service-queues.resource.ts

@@ -5,12 +5,22 @@ import {
   type MappedEncounter,
   type MappedVisitQueueEntry,
   type QueueEntry,
+  type Queue,
+  type CreateQueueDto,
+  type QueueRoom,
+  type CreateQueueRoomDto,
 } from '../types/types';
 import dayjs from 'dayjs';
 import useSWR from 'swr';
 import { useMemo } from 'react';
-import { type QueueEntryResult } from '../registry/types';
+import { type QueueEntryResult, type RegistrationQueueList } from '../registry/types';
 import { getEtlBaseUrl } from '../shared/utils/get-base-url';
+import {
+  type ServiceQueueDailyPatientListReportResp,
+  type ServiceQueueDailyReport,
+  type ServiceQueueDailyReportResp,
+  type ServiceQueueReportPatientList,
+} from '../shared/types';
 
 export function serveQueueEntry(servicePointName: string, ticketNumber: string, status: string) {
   const abortController = new AbortController();
@@ -175,3 +185,189 @@ export async function closeQueueEntry(entryQueueUuid: string): Promise<QueueEntr
   const result = await response.json();
   return result.data;
 }
+
+export async function getQueuesByLocationUuid(locationUuid: string): Promise<Queue[]> {
+  const queueUrl = `${restBaseUrl}/queue`;
+  const params = {
+    location: locationUuid,
+    v: 'full',
+  };
+  const queryString = new URLSearchParams(params).toString();
+  const response = await openmrsFetch(`${queueUrl}?${queryString}`);
+  const result = await response.json();
+  return result.results;
+}
+
+export async function deleteQueue(queueUuid: string): Promise<any> {
+  const queueUrl = `${restBaseUrl}/queue/${queueUuid}?!purge`;
+  const response = await openmrsFetch(queueUrl, {
+    method: 'DELETE',
+  });
+  return response;
+}
+
+export async function createQueue(createQueueDto: CreateQueueDto): Promise<Queue> {
+  const createQueueUrl = `${restBaseUrl}/queue/`;
+  const response = await openmrsFetch(createQueueUrl, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(createQueueDto),
+  });
+  const result = await response.json();
+  return result;
+}
+
+export async function editQueue(queueUuid: string, editQueueDto: CreateQueueDto): Promise<Queue> {
+  const editQueueUrl = `${restBaseUrl}/queue/${queueUuid}`;
+  const response = await openmrsFetch(editQueueUrl, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(editQueueDto),
+  });
+  const result = await response.json();
+  return result;
+}
+
+export async function getQueueRoomsByLocationUuid(locationUuid: string): Promise<QueueRoom[]> {
+  const queueUrl = `${restBaseUrl}/queue-room`;
+  const v =
+    'custom:(uuid,display,name,description,queue:(uuid,display,location:(uuid,display),service:(uuid,display)))';
+  const params = {
+    location: locationUuid,
+    v: v,
+  };
+  const queryString = new URLSearchParams(params).toString();
+  const response = await openmrsFetch(`${queueUrl}?${queryString}`);
+  const result = await response.json();
+  return result.results;
+}
+
+export async function createQueueRoom(createQueueRoomDto: CreateQueueRoomDto): Promise<QueueRoom> {
+  const createQueueUrl = `${restBaseUrl}/queue-room/`;
+  const response = await openmrsFetch(createQueueUrl, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(createQueueRoomDto),
+  });
+  const result = await response.json();
+  return result;
+}
+
+export async function deleteQueueRoom(queueRoomUuid: string): Promise<any> {
+  const queueUrl = `${restBaseUrl}/queue-room/${queueRoomUuid}?!purge`;
+  const response = await openmrsFetch(queueUrl, {
+    method: 'DELETE',
+  });
+  return response;
+}
+
+export async function editQueueRoom(queueRoomUuid: string, editQueueRoomDto: CreateQueueRoomDto): Promise<QueueRoom> {
+  const editQueueUrl = `${restBaseUrl}/queue-room/${queueRoomUuid}`;
+  const response = await openmrsFetch(editQueueUrl, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(editQueueRoomDto),
+  });
+  const result = await response.json();
+  return result;
+}
+export async function getActiveQueueEntryByPatientUuid(patientUuid: string): Promise<QueueEntry[]> {
+  const queueUrl = `${restBaseUrl}/queue-entry`;
+  const v =
+    'custom:(uuid,display,queue,status,patient:(uuid,display,person,identifiers:(uuid,display,identifier,identifierType)),visit:(uuid,display,startDatetime,encounters:(uuid,display,diagnoses,encounterDatetime,encounterType,obs,encounterProviders,voided),attributes:(uuid,display,value,attributeType)),priority,priorityComment,sortWeight,startedAt,endedAt,locationWaitingFor,queueComingFrom,providerWaitingFor,previousQueueEntry)';
+  const params = {
+    patient: patientUuid,
+    v: v,
+    isEnded: 'false',
+    totalCount: 'true',
+  };
+  const queryString = new URLSearchParams(params).toString();
+  const response = await openmrsFetch(`${queueUrl}?${queryString}`);
+  const result = await response.json();
+  return result.results;
+}
+
+export async function getServiceQueueDailyReport(
+  serviceUuid: string,
+  locationUuid: string,
+): Promise<ServiceQueueDailyReport[]> {
+  const etlBaseUrl = await getEtlBaseUrl();
+  const reportUrl = `${etlBaseUrl}/service-queue-daily-report?serviceUuid=${serviceUuid}&locationUuid=${locationUuid}`;
+  const response = await openmrsFetch<ServiceQueueDailyReportResp>(reportUrl);
+  const result = await response.json();
+  return result.result;
+}
+
+export async function getServiceQueueDailyPatientListReport(
+  serviceUuid: string,
+  locationUuid: string,
+): Promise<ServiceQueueReportPatientList[]> {
+  const etlBaseUrl = await getEtlBaseUrl();
+  const reportUrl = `${etlBaseUrl}/service-queue-daily-report/patient-list?serviceUuid=${serviceUuid}&locationUuid=${locationUuid}`;
+  const response = await openmrsFetch<ServiceQueueDailyPatientListReportResp>(reportUrl);
+  const result: ServiceQueueDailyPatientListReportResp = await response.json();
+  if (result && result.results) {
+    return result.results.results ?? [];
+  } else {
+    return [];
+  }
+}
+export async function getQueueEntryByLocationUuid(locationUuid: string): Promise<QueueEntry[]> {
+  const queueUrl = `${restBaseUrl}/queue-entry`;
+  const v =
+    'custom:(uuid,display,queue,status,patient:(uuid,display,person),visit:(uuid,display,startDatetime,stopDatetime),priority,priorityComment,sortWeight,startedAt,endedAt,locationWaitingFor,queueComingFrom,providerWaitingFor,previousQueueEntry)';
+  const params = {
+    location: locationUuid,
+    v: v,
+    isEnded: 'false',
+    totalCount: 'true',
+  };
+  const queryString = new URLSearchParams(params).toString();
+  const response = await openmrsFetch(`${queueUrl}?${queryString}`);
+  const result = await response.json();
+  return result.results;
+}
+
+export async function deleteQueueEntry(queueEntryUuid: string): Promise<any> {
+  const queueUrl = `${restBaseUrl}/queue-entry/${queueEntryUuid}?!purge`;
+  const response = await openmrsFetch(queueUrl, {
+    method: 'DELETE',
+  });
+  return response;
+}
+
+export async function endQueueEntry(entryQueueUuid: string, endedAt: string): Promise<QueueEntryResult[]> {
+  const queueEntryUrl = `${restBaseUrl}/queue-entry/${entryQueueUuid}`;
+  const params = {
+    endedAt: endedAt,
+  };
+  const response = await openmrsFetch(queueEntryUrl, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(params),
+  });
+  const result = await response.json();
+  return result.data;
+}
+
+export async function getRegistrationQueueList(
+  locationUuid: string,
+  startDate: string,
+  endDate: string
+): Promise<RegistrationQueueList[]> {
+  const etlBaseUrl = await getEtlBaseUrl();
+  const reportUrl = `${etlBaseUrl}/queue-entry/registration?locationUuid=${locationUuid}&startDate=${startDate}&endDate=${endDate}`;
+  const response = await openmrsFetch(reportUrl);
+  const result: { data: RegistrationQueueList[] } = await response.json();
+  return result.data ?? [];
+}

package/src/service-queues/service.resource.ts

@@ -4,7 +4,7 @@ import { type TransitionQueueEntryDto } from '../types/types';
 
 export async function getServiceQueueByLocation(locationUuid: string): Promise<ServiceQueue[]> {
   const params = {
-    v: 'custom:(uuid,name)',
+    v: 'custom:(uuid,name,location:(uuid,display))',
     location: locationUuid,
   };
   const queryString = new URLSearchParams(params).toString();

package/src/shared/constants/concepts.ts

@@ -1,5 +1,6 @@
 const NORMAL_PRIORITY_UUID = 'bbd99c12-67e9-4381-8b4c-1f231e86f8e2';
 const EMERGENCY_PRIORITY_UUID = '8e86ff12-ec83-41e8-a534-bb410739d880';
+const NOT_URGENT_PRIORITY_UUID = '26995049-fc00-43f4-a725-851fd517a1ac';
 
 const WAITING_UUID = '89d01aa5-0ab0-4626-934b-37766b4cd779';
 const IN_SERVICE_UUID = 'f9cf5768-508f-45de-8d40-eaf6ea3f3b02';
@@ -8,9 +9,39 @@ const COMPLETED_UUID = 'a89c1ef8-1350-11df-a1f1-0026b9348838';
 const TRIAGE_SERVICE_UUID = '2d4472e2-d7ab-4430-8e0e-a9ffcd809bf4';
 const CLINICAL_CONSULTATION_SERVICE_UUID = '7f7ec7ad-cdd7-4ed9-bc2e-5c5bd9f065b2';
 
+const MCH_TRIAGE_SERVICE_UUID = '7e4452bf-f9b7-4977-a21f-1c8b94831bac';
+const MCH_CLINICAL_CONSULTATION_SERVICE_UUID = '0026e273-5f8c-46b5-8bb4-0d8301d50321';
+
+const MATERNITY_TRIAGE_SERVICE_UUID = 'c00a4436-a719-4b55-b3ae-7c22165d4ac2';
+
+const DIALYSIS_TRIAGE_SERVICE_UUID = '42740522-d367-4d98-ac14-2f71c3848c94';
+const DIALYSIS_CONSULTATION_SERVICE_UUID = '580a9861-810f-4bd7-b5ed-dd3f1547d9d4';
+
+const ONCOLOGY_TRIAGE_SERVICE_UUID = '863b9dee-6580-41fc-a891-74146a6dca47';
+const ONCOLOGY_CONSULTATION_SERVICE_UUID = '0e883ef1-91ad-4d6d-81f3-cfa19f3164f8';
+
+const DENTAL_TRIAGE_SERVICE_UUID = 'da0f8512-736e-4b57-8a08-97e0e316669c';
+const DENTAL_CONSULTATION_SERVICE_UUID = '7b504b4f-f36d-4437-ba12-fc41a8a468e5';
+
+const DIAGNOSTIC_AND_IMAGING_TRIAGE_SERVICE_UUID = '42f094b8-3898-4103-95c3-1b96b3bf17ae';
+const DIAGNOSTIC_AND_IMAGING_CONSULTATION_SERVICE_UUID = 'ae066325-6fb2-4cf4-9652-75757f0c278f';
+
+const OPTHALMOLOGY_TRIAGE_SERVICE_UUID = 'e6396560-f3b1-45e4-8dbf-fd41e2127bda';
+const OPTHALMOLOGY_CONSULTATION_SERVICE_UUID = 'd757a3fd-fc8f-44be-bcc7-9546913e976c';
+
+const PSYCHIATRY_TRIAGE_SERVICE_UUID = 'af2ddf7a-f6ba-431f-a2cb-53c2e69258ae';
+const PSYCHIATRY_CONSULTATION_SERVICE_UUID = '5c1d5b4b-e526-4973-9461-f8e3920f184e';
+
+const CRITICAL_CARE_UNIT_TRIAGE_SERVICE_UUID = 'df7038f9-9b5d-4544-9f98-be78fba59f99';
+const CRITICAL_CARE_UNIT_CONSULTATION_SERVICE_UUID = '65bb7dc2-e289-4a37-99dd-cbdae293a7ba';
+
+const PALLIATIVE_CARE_TRIAGE_SERVICE_UUID = 'd1bff1ec-dc6b-49ef-8f29-e1478cb5fd48';
+const PALLIATIVE_CARE_CONSULTATION_SERVICE_UUID = 'a533982e-1fad-4d59-9823-48fb6cdde533';
+
 export const QUEUE_PRIORITIES_UUIDS = {
   NORMAL_PRIORITY_UUID,
   EMERGENCY_PRIORITY_UUID,
+  NOT_URGENT_PRIORITY_UUID,
 };
 
 export const QUEUE_STATUS_UUIDS = {
@@ -22,4 +53,23 @@ export const QUEUE_STATUS_UUIDS = {
 export const QUEUE_SERVICE_UUIDS = {
   TRIAGE_SERVICE_UUID,
   CLINICAL_CONSULTATION_SERVICE_UUID,
+  MCH_TRIAGE_SERVICE_UUID,
+  MCH_CLINICAL_CONSULTATION_SERVICE_UUID,
+  MATERNITY_TRIAGE_SERVICE_UUID,
+  DIALYSIS_TRIAGE_SERVICE_UUID,
+  DIALYSIS_CONSULTATION_SERVICE_UUID,
+  ONCOLOGY_TRIAGE_SERVICE_UUID,
+  ONCOLOGY_CONSULTATION_SERVICE_UUID,
+  DENTAL_TRIAGE_SERVICE_UUID,
+  DENTAL_CONSULTATION_SERVICE_UUID,
+  DIAGNOSTIC_AND_IMAGING_TRIAGE_SERVICE_UUID,
+  DIAGNOSTIC_AND_IMAGING_CONSULTATION_SERVICE_UUID,
+  OPTHALMOLOGY_TRIAGE_SERVICE_UUID,
+  OPTHALMOLOGY_CONSULTATION_SERVICE_UUID,
+  PSYCHIATRY_TRIAGE_SERVICE_UUID,
+  PSYCHIATRY_CONSULTATION_SERVICE_UUID,
+  CRITICAL_CARE_UNIT_TRIAGE_SERVICE_UUID,
+  CRITICAL_CARE_UNIT_CONSULTATION_SERVICE_UUID,
+  PALLIATIVE_CARE_TRIAGE_SERVICE_UUID,
+  PALLIATIVE_CARE_CONSULTATION_SERVICE_UUID
 };

package/src/shared/constants/patient-category.ts

@@ -0,0 +1,6 @@
+const CCC_PATIENT_UUID = 'a8a3899a-1350-11df-a1f1-0026b9348838';
+const MCH_PATIENT_UUID = 'a8a17d80-1350-11df-a1f1-0026b9348838';
+export const PatientCategories = {
+  CCC_PATIENT_UUID,
+  MCH_PATIENT_UUID,
+};

package/src/shared/constants/patient-type.ts

@@ -0,0 +1,10 @@
+const WALK_IN_UUID = '1671c96d-f281-49bf-b246-c0698f200871';
+const SELF_RERERRAL_UUID = 'a8a17d80-1350-11df-a1f1-0026b9348838';
+const REFERRAL_FROM_ANOTHER_FACILITY_UUID = 'a095f6aa-9d15-442e-8b21-d9306b82983f';
+const REFERRED_BY_COMMUNITY_HEALTH_WORKER_UUID = '1d54b745-0afc-4568-a9ba-17ba3fc1dda0';
+export const PatientTypes = {
+  WALK_IN_UUID,
+  SELF_RERERRAL_UUID,
+  REFERRAL_FROM_ANOTHER_FACILITY_UUID,
+  REFERRED_BY_COMMUNITY_HEALTH_WORKER_UUID
+};

package/src/shared/constants/visit-types.ts

@@ -0,0 +1,7 @@
+const OPD_VISIT_TYPE_UUID = '57d7f623-6a5c-47b2-a1b0-0238b92bea95';
+const INPATIENT_VISIT_TYPE_UUID = 'be7c422a-9f7d-4817-95d0-0e4d451ad153';
+
+export const VisitTypeUuids = {
+  OPD_VISIT_TYPE_UUID,
+  INPATIENT_VISIT_TYPE_UUID,
+};