@pih/esm-commons-app 2.1.1-pre.15 → 2.1.1-pre.151

package/src/hooks/useEncounters.ts

@@ -0,0 +1,22 @@
+import { restBaseUrl, useOpenmrsFetchAll } from '@openmrs/esm-framework';
+import { type Encounter } from '../service-queues-app/types';
+
+interface EncounterSearchParams {
+  patient: string;
+  visit?: string;
+  encounterType?: string;
+}
+
+export function useEncounters(params: EncounterSearchParams) {
+  const url = `${restBaseUrl}/encounter?`;
+  const searchParams = new URLSearchParams();
+  searchParams.append('patient', params.patient);
+  if (params.visit) {
+    searchParams.append('visit', params.visit);
+  }
+  if (params.encounterType) {
+    searchParams.append('encounterType', params.encounterType);
+  }
+
+  return useOpenmrsFetchAll<Encounter>(url + searchParams.toString());
+}

package/src/hooks/useVisitAttribute.ts

@@ -0,0 +1,37 @@
+import { restBaseUrl, useOpenmrsFetchAll } from '@openmrs/esm-framework';
+
+export interface VisitAttribute {
+  uuid: string;
+  display?: string;
+  value: boolean | string | number;
+  attributeType: {
+    uuid: string;
+    display?: string;
+  };
+}
+
+// prettier-ignore
+const visitAttributeCustomRepresentation =
+  'custom:(uuid,value,attributeType:(uuid,display))';
+
+/**
+ * Fetches the attribute of a given type for a given visit.
+ *
+ * The default visit representation used by the ward admission/request hooks does not include
+ * attribute values, so this hook queries the visit's attribute subresource directly and returns the
+ * single attribute matching `attributeTypeUuid` (or `undefined` if the visit has no such attribute).
+ *
+ * @param visitUuid the visit whose attributes to fetch. When falsy, no request is made.
+ * @param attributeTypeUuid the visit attribute type to look for.
+ */
+export function useVisitAttribute(visitUuid: string, attributeTypeUuid: string) {
+  const apiUrl = visitUuid
+    ? `${restBaseUrl}/visit/${visitUuid}/attribute?v=${visitAttributeCustomRepresentation}`
+    : null;
+
+  const { data, ...rest } = useOpenmrsFetchAll<VisitAttribute>(apiUrl);
+
+  const attribute = data?.find((attr) => attr.attributeType?.uuid === attributeTypeUuid);
+
+  return { attribute, value: attribute?.value, ...rest };
+}

package/src/index.ts

@@ -5,31 +5,58 @@
  * microfrontend.
  */
 
-import { getAsyncLifecycle } from '@openmrs/esm-framework';
+import { getAsyncLifecycle, defineConfigSchema } from '@openmrs/esm-framework';
+import { configSchema } from './config-schema';
 
 const moduleName = '@pih/esm-commons-app';
-const options = {
-  featureName: 'commons',
-  moduleName,
-};
 
 export const importTranslation = require.context('../translations', false, /.json$/, 'lazy');
 
-// export const root = getAsyncLifecycle(() => import('./root.component'), options);
-
 export const o2VisitSummaryWorkspaceSideRailIcon = getAsyncLifecycle(
-  () => import('./ward-app/o2-visit-summary-action-button.extension'),
-  options,
+  () => import('./ward-app/o2-visit-summary-action-button.component'),
+  { featureName: 'o2VisitSummaryWorkspaceSideRailIcon', moduleName },
 );
 
 export const o2VisitSummaryWorkspace = getAsyncLifecycle(
   () => import('./ward-app/o2-visit-summary-workspace.component'),
-  options,
+  { featureName: 'o2VisitSummaryWorkspace', moduleName },
+);
+
+export const o2VitalSignsWorkspaceSideRailIcon = getAsyncLifecycle(
+  () => import('./ward-app/o2-vital-signs-action-button.component'),
+  { featureName: 'o2VitalSignsWorkspaceSideRailIcon', moduleName },
 );
 
+export const o2VitalSignsWorkspace = getAsyncLifecycle(() => import('./ward-app/o2-vital-signs-workspace.component'), {
+  featureName: 'o2VitalSignsWorkspace',
+  moduleName,
+});
+
 export const o2PregnancyInfantDashboard = getAsyncLifecycle(
   () => import('./ward-app/o2-pregnancy-infant-dashboard.extension'),
-  options,
+  { featureName: 'o2PregnancyInfantDashboard', moduleName },
+);
+
+export const maternalTriageFormWorkspace = getAsyncLifecycle(
+  () => import('./service-queues-app/maternal-triage-form.workspace'),
+  { featureName: 'maternalTriageFormWorkspace', moduleName },
+);
+
+export const triageWaitingQueueActions = getAsyncLifecycle(
+  () => import('./service-queues-app/maternal-triage-queue-actions.extension'),
+  { featureName: 'triageWaitingQueueActions', moduleName },
 );
 
-export function startupApp() {}
+export const zebraLabelPrintAction = getAsyncLifecycle(
+  () => import('./dispensing/zebra-label-print-action.extension'),
+  { featureName: 'zebraLabelPrintAction', moduleName },
+);
+
+export const inbornOutbornTag = getAsyncLifecycle(() => import('./ward-app/inborn-outborn-tag-row.extension'), {
+  featureName: 'inbornOutbornTag',
+  moduleName,
+});
+
+export function startupApp() {
+  defineConfigSchema(moduleName, configSchema);
+}

package/src/routes.json

@@ -1,28 +1,82 @@
 {
   "$schema": "https://json.openmrs.org/routes.schema.json",
   "pages": [
-  ],
-  "extensions": [
     {
-      "name": "o2-visit-summary-workspace-siderail-button",
-      "component": "o2VisitSummaryWorkspaceSideRailIcon",
-      "slot": "action-menu-ward-patient-items-slot"
+      "component": "root",
+      "route": "appointments"
+    },
+    {
+      "component": "root",
+      "route": "service-queues"
     },
+    {
+      "component": "root",
+      "route": "dispensing2"
+    },
+    {
+      "component": "root",
+      "route": "ward"
+    }
+  ],
+  "extensions": [
     {
       "name": "o2-pregnancy-infant-dashboard",
       "component": "o2PregnancyInfantDashboard",
       "slot": "ward-patient-workspace-content-slot"
+    },
+    {
+      "name": "triage-waiting-queue-actions",
+      "component": "triageWaitingQueueActions",
+      "slot": "queue-table-triage-waiting-queue-actions-slot"
+    },
+    {
+      "name": "zebra-label-print-action",
+      "component": "zebraLabelPrintAction",
+      "slot": "medication-dispense-action-slot"
+    },
+    {
+      "name": "inborn-outborn-tag",
+      "component": "inbornOutbornTag",
+      "slot": "maternal-ward-patient-card-header-slot"
     }
   ],
-  "workspaces": [
+  "workspaces2": [
     {
       "name": "o2-visit-summary-workspace",
       "component": "o2VisitSummaryWorkspace",
-      "title": "visitSummary",
-      "type": "o2-visit-summary",
-      "sidebarFamily": "ward-patient",
-      "hasOwnSidebar": true,
-      "width": "extra-wide"
+      "window": "o2-visit-summary-window"
+    },
+    {
+      "name": "o2-vital-signs-workspace",
+      "component": "o2VitalSignsWorkspace",
+      "window": "o2-vital-signs-window"
+    },
+    {
+      "name": "maternal-triage-form-workspace",
+      "component": "maternalTriageFormWorkspace",
+      "window": "maternal-triage-form-window"
+    }
+  ],
+  "workspaceWindows2": [
+    {
+      "name": "o2-visit-summary-window",
+      "icon": "o2VisitSummaryWorkspaceSideRailIcon",
+      "group": "ward-patient",
+      "width": "extra-wide",
+      "canMaximize": true
+    },
+    {
+      "name": "o2-vital-signs-window",
+      "icon": "o2VitalSignsWorkspaceSideRailIcon",
+      "group": "ward-patient",
+      "width": "extra-wide",
+      "canMaximize": true
+    },
+    {
+      "name": "maternal-triage-form-window",
+      "group": "service-queues",
+      "width": "extra-wide",
+      "canMaximize": true
     }
   ]
 }

package/src/service-queues-app/maternal-triage-form.workspace.tsx

@@ -0,0 +1,111 @@
+import { type Patient, showSnackbar, Workspace2, type Workspace2DefinitionProps } from '@openmrs/esm-framework';
+import React, { useEffect } from 'react';
+import { useTranslation } from 'react-i18next';
+import O2IFrame from '../ward-app/o2-iframe.component';
+import { updateQueueEntry, useMutateQueueEntries } from './maternal-triage-queue-actions.resource';
+import { type QueueEntry } from './types';
+import { useEncounters } from '../hooks/useEncounters';
+import { Loading } from '@carbon/react';
+import { InlineNotification } from '@carbon/react';
+
+interface MaternalTriageFormWorkspaceProps {
+  queueEntry: QueueEntry;
+  patient: Patient;
+}
+
+const MATERNAL_TRIAGE_FORM_ENCOUNTER_TYPE = '41911448-71a1-43d7-bba8-dc86339850da';
+
+/**
+ * Workspace to display the Maternal Triage HTML Form, rendered in a iframe
+ */
+const MaternalTriageFormWorkspace: React.FC<Workspace2DefinitionProps<MaternalTriageFormWorkspaceProps>> = ({
+  workspaceProps: { queueEntry, patient },
+  closeWorkspace,
+}) => {
+  const { t } = useTranslation();
+  const { mutateQueueEntries } = useMutateQueueEntries();
+  const {
+    data: filledOutTriageForms,
+    isLoading,
+    error,
+  } = useEncounters({
+    patient: patient.uuid,
+    visit: queueEntry.visit.uuid,
+    encounterType: MATERNAL_TRIAGE_FORM_ENCOUNTER_TYPE,
+  });
+
+  useEffect(() => {
+    const onMessage = async (event: MessageEvent) => {
+      if (event.data == 'triageFormSubmitted') {
+        const endQueueEntry = () => {
+          return updateQueueEntry(queueEntry.uuid, {
+            endedAt: new Date().toISOString(),
+          });
+        };
+
+        await endQueueEntry();
+        await mutateQueueEntries();
+        closeWorkspace({ discardUnsavedChanges: true });
+        showSnackbar({
+          isLowContrast: true,
+          kind: 'success',
+          title: t('triageFormSubmitted', 'Triage form successfully submitted for {{patient}}.', {
+            patient: patient.person.display,
+          }),
+        });
+      }
+    };
+
+    window.addEventListener('message', onMessage);
+    return () => window.removeEventListener('message', onMessage);
+  }, []);
+
+  const patientUuid = patient.uuid;
+  const visitUuid = queueEntry.visit.uuid;
+
+  const elementsToHide = [
+    'header',
+    '#breadcrumbs',
+
+    // prevent O2 success toast from showing; After submitting form for a patient,
+    // the success toast for that patient shows when opening form for another patient
+    '.toast-type-success',
+    // UHM-8822: remove Cancel button from the triage form
+    '.cancel',
+  ];
+
+  const customJavaScript = `
+    htmlForm.setSuccessFunction(() => window.top.postMessage('triageFormSubmitted'))
+  `;
+
+  if (isLoading) {
+    return <Loading withOverlay={false} small />;
+  } else if (error) {
+    return (
+      <InlineNotification
+        kind="error"
+        lowContrast={true}
+        hideCloseButton={true}
+        title={t('errorLoadingPatientForm', 'Error loading patient form')}
+      />
+    );
+  } else {
+    // If patient does not have triage form filled out already, we load a new one,
+    // else, we load the last filled out form to edit
+    const src =
+      filledOutTriageForms.length == 0
+        ? `${window.openmrsBase}/htmlformentryui/htmlform/enterHtmlFormWithStandardUi.page?patientId=${patientUuid}&visitId=${visitUuid}&definitionUiResource=file:configuration/pih/htmlforms/triage.xml&returnUrl=%2Fopenmrs%2Fcoreapps%2Fclinicianfacing%2Fpatient.page%3FpatientId%3D${patientUuid}%26`
+        : `${window.openmrsBase}/htmlformentryui/htmlform/editHtmlFormWithStandardUi.page?patientId=${patientUuid}&encounterId=${filledOutTriageForms[filledOutTriageForms.length - 1].uuid}`;
+
+    return (
+      <Workspace2
+        title={t('maternalTriageForm', 'Maternal triage form')}
+        hasUnsavedChanges={true} // assume there are unsaved changes to prevent accidental closure
+      >
+        <O2IFrame key={patientUuid} src={src} elementsToHide={elementsToHide} customJavaScript={customJavaScript} />
+      </Workspace2>
+    );
+  }
+};
+
+export default MaternalTriageFormWorkspace;

package/src/service-queues-app/maternal-triage-queue-actions.extension.tsx

@@ -0,0 +1,132 @@
+import { Button, OverflowMenu, OverflowMenuItem } from '@carbon/react';
+import { isDesktop, launchWorkspace2, showModal, useConfig, useLayoutType } from '@openmrs/esm-framework';
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import styles from './maternal-trial-queue-actions.scss';
+import { type QueueEntry } from './types';
+import { transitionQueueEntry, useMutateQueueEntries } from './maternal-triage-queue-actions.resource';
+
+// types taken from esm-service-queues-app
+interface QueueTableCellComponentProps {
+  queueEntry: QueueEntry;
+}
+
+interface ConfigObject {
+  concepts: {
+    defaultTransitionStatus: string;
+  };
+  // other fields not shown
+}
+
+/**
+ * This extension provides an extra "Triage" action, along with the other standard actions for
+ * queue entries in the queues table. The Triage action opens the maternal triage form, and also
+ * has the side effect of putting the patient's queue entry into the "in service" status, if they have
+ * not yet already
+ * @param param0
+ * @returns
+ */
+const MaternalTriageQueueActions: React.FC<QueueTableCellComponentProps> = ({ queueEntry }) => {
+  const { t } = useTranslation();
+  const layout = useLayoutType();
+
+  const { mutateQueueEntries } = useMutateQueueEntries();
+  const { concepts } = useConfig<ConfigObject>({ externalModuleName: '@openmrs/esm-service-queues-app' });
+  const inServiceStatus = concepts.defaultTransitionStatus;
+
+  const { patient } = queueEntry;
+
+  return (
+    <div className={styles.actionsCell}>
+      <Button
+        kind="ghost"
+        aria-label={t('triage', 'Triage')}
+        onClick={async () => {
+          if (queueEntry.status.uuid !== inServiceStatus) {
+            const res = await transitionQueueEntry({
+              queueEntryToTransition: queueEntry.uuid,
+              newStatus: inServiceStatus,
+            });
+            mutateQueueEntries();
+            const updatedQueueEntry = { ...res.data, visit: queueEntry.visit };
+            launchWorkspace2('maternal-triage-form-workspace', { queueEntry: updatedQueueEntry, patient });
+          } else {
+            launchWorkspace2('maternal-triage-form-workspace', { queueEntry, patient });
+          }
+        }}
+        size={isDesktop(layout) ? 'sm' : 'lg'}>
+        {t('triage', 'Triage')}
+      </Button>
+
+      <OverflowMenu aria-label="Actions menu" size={isDesktop(layout) ? 'sm' : 'lg'} align="left" flipped>
+        <OverflowMenuItem
+          className={styles.menuItem}
+          aria-label={t('transition', 'Transition')}
+          hasDivider
+          onClick={() => {
+            const dispose = showModal('transition-queue-entry-modal', {
+              closeModal: () => dispose(),
+              queueEntry,
+            });
+          }}
+          itemText={t('transition', 'Transition')}
+        />
+        <OverflowMenuItem
+          className={styles.menuItem}
+          aria-label={t('edit', 'Edit')}
+          hasDivider
+          onClick={() => {
+            const dispose = showModal('edit-queue-entry-modal', {
+              closeModal: () => dispose(),
+              queueEntry,
+            });
+          }}
+          itemText={t('edit', 'Edit')}
+        />
+        <OverflowMenuItem
+          className={styles.menuItem}
+          aria-label={t('removePatient', 'Remove patient')}
+          hasDivider
+          onClick={() => {
+            const dispose = showModal('remove-queue-entry-modal', {
+              closeModal: () => dispose(),
+              queueEntry,
+            });
+          }}
+          itemText={t('removePatient', 'Remove patient')}
+        />
+        {queueEntry.previousQueueEntry == null ? (
+          <OverflowMenuItem
+            className={styles.menuItem}
+            aria-label={t('delete', 'Delete')}
+            hasDivider
+            isDelete
+            onClick={() => {
+              const dispose = showModal('delete-queue-entry-modal', {
+                closeModal: () => dispose(),
+                queueEntry,
+              });
+            }}
+            itemText={t('delete', 'Delete')}
+          />
+        ) : (
+          <OverflowMenuItem
+            className={styles.menuItem}
+            aria-label={t('undoTransition', 'Undo transition')}
+            hasDivider
+            isDelete
+            onClick={() => {
+              const dispose = showModal('undo-transition-queue-entry-modal', {
+                closeModal: () => dispose(),
+                queueEntry,
+              });
+            }}
+            itemText={t('undoTransition', 'Undo transition')}
+          />
+        )}
+      </OverflowMenu>
+    </div>
+  );
+};
+
+export default MaternalTriageQueueActions;

package/src/service-queues-app/maternal-triage-queue-actions.resource.ts

@@ -0,0 +1,84 @@
+import { type Concept, type FetchResponse, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { useSWRConfig } from 'swr';
+import { type QueueEntry } from './types';
+import { useCallback, useMemo } from 'react';
+
+// Hooks here copied from esm-service-queues-app
+
+export function useMutateQueueEntries() {
+  const { mutate, cache } = useSWRConfig();
+  const mutateQueueEntries = useCallback(() => {
+    const promises: Promise<unknown>[] = [];
+    for (const key of cache.keys()) {
+      if (key.includes(`${restBaseUrl}/queue-entry`) || key.includes(`${restBaseUrl}/visit-queue-entry`)) {
+        promises.push(mutate(key));
+      }
+    }
+    return Promise.all(promises);
+  }, [mutate, cache]);
+
+  return useMemo(
+    () => ({
+      mutateQueueEntries,
+    }),
+    [mutateQueueEntries],
+  );
+}
+
+interface TransitionQueueEntryParams {
+  queueEntryToTransition: string;
+  transitionDate?: string;
+  newQueue?: string;
+  newStatus?: string;
+  newPriority?: string;
+  newPriorityComment?: string;
+}
+
+/**
+ * A transition is defined as an action that ends a current queue entry and immediately starts a new one
+ * with (slightly) different values. For now, this could be used to transition the queue entry's status,
+ * priority or queue. This allows us to keep a history of queue entries through a patient's visit.
+ * Note that there are some use cases (like RDE or data correction) where a transition is NOT appropriate.
+ * @param params
+ * @param abortController
+ * @returns
+ */
+export function transitionQueueEntry(
+  params: TransitionQueueEntryParams,
+  abortController?: AbortController,
+): Promise<FetchResponse<QueueEntry>> {
+  return openmrsFetch(`${restBaseUrl}/queue-entry/transition`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    signal: abortController?.signal,
+    body: params,
+  });
+}
+
+interface UpdateQueueEntryParams {
+  status?: Concept;
+  priority?: Concept;
+  priorityComment?: string;
+  sortWeight?: number;
+  startedAt?: string;
+  endedAt?: string;
+  loationWaitingFor?: Location;
+  providerWaitingFor?: Location;
+}
+
+export function updateQueueEntry(
+  queueEntryUuid: string,
+  params: UpdateQueueEntryParams,
+  abortController?: AbortController,
+) {
+  return openmrsFetch(`${restBaseUrl}/queue-entry/${queueEntryUuid}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    signal: abortController?.signal,
+    body: params,
+  });
+}

package/src/service-queues-app/maternal-trial-queue-actions.scss

@@ -0,0 +1,14 @@
+.actionCellContainer {
+  white-space: nowrap;
+}
+
+.menuItem {
+  max-width: none;
+}
+
+.actionsCell {
+  display: flex;
+  justify-content: flex-end;
+  height: 100%;
+  align-items: center;
+}

package/src/service-queues-app/types.ts

@@ -0,0 +1,58 @@
+import { type Concept, type OpenmrsResource, type Patient, type Visit } from '@openmrs/esm-framework';
+
+export interface Queue {
+  uuid: string;
+  display: string;
+  name: string;
+  description: string;
+  location: Location;
+  service: Concept;
+  allowedPriorities: Array<Concept>;
+  allowedStatuses: Array<Concept>;
+}
+
+export interface QueueEntry {
+  uuid: string;
+  display: string;
+  endedAt: string;
+  locationWaitingFor: Location;
+  patient: Patient;
+  priority: Concept;
+  priorityComment: string | null;
+  providerWaitingFor: Provider;
+  queue: Queue;
+  startedAt: string;
+  status: Concept;
+  visit: Visit;
+  sortWeight: number;
+  queueComingFrom: Queue;
+  previousQueueEntry: QueueEntry;
+}
+
+export interface Provider extends OpenmrsResource {}
+
+export interface Encounter {
+  uuid: string;
+  encounterDateTime: string;
+  encounterProviders: Array<{
+    uuid: string;
+    display: string;
+    encounterRole: {
+      uuid: string;
+      display: string;
+    };
+    provider: {
+      uuid: string;
+      person: {
+        uuid: string;
+        display: string;
+      };
+    };
+  }>;
+  encounterType: {
+    uuid: string;
+    display: string;
+  };
+  obs: Array<OpenmrsResource>;
+  orders: Array<OpenmrsResource>;
+}