@openmrs/esm-fast-data-entry-app 1.4.2-pre.624 → 1.4.2-pre.628

package/src/context/GroupFormWorkflowContext.tsx

@@ -12,6 +12,20 @@ export interface GroupType {
   id: string;
   name: string;
   members: Array<Type.Object>;
+  location?: {
+    uuid: string;
+    display?: string;
+  };
+  cohortMembers?: Array<{
+    patient: {
+      uuid?: string;
+      person?: {
+        names?: Array<{
+          display?: string;
+        }>;
+      };
+    };
+  }>;
 }
 
 export interface MetaType {

package/src/form-entry-workflow/patient-search-header/PatientSearchHeader.test.tsx

@@ -0,0 +1,121 @@
+import React from 'react';
+import { render, screen, fireEvent, cleanup, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import PatientSearchHeader from './PatientSearchHeader';
+import FormWorkflowContext from '../../context/FormWorkflowContext';
+import { showSnackbar, useConfig, useSession, type ConfigSchema, type Session } from '@openmrs/esm-framework';
+import { useHsuIdIdentifier } from '../../hooks/location-tag.resource';
+
+jest.mock('@openmrs/esm-framework', () => ({
+  ExtensionSlot: ({ state }) => (
+    <button data-testid="mock-search-select" onClick={() => state.selectPatientAction('patient-123')}>
+      Select Patient
+    </button>
+  ),
+  interpolateUrl: jest.fn((url) => url),
+  navigate: jest.fn(),
+  showSnackbar: jest.fn(),
+  useConfig: jest.fn(),
+  useSession: jest.fn(),
+}));
+
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key: string, defaultValue: string, interpolation: { hsuLocation?: string; sessionLocation?: string }) => {
+      if (interpolation?.hsuLocation) {
+        return `Error: Patient at ${interpolation.hsuLocation} cannot be added to session at ${interpolation.sessionLocation}`;
+      }
+      return defaultValue || key;
+    },
+  }),
+}));
+
+jest.mock('../../hooks/location-tag.resource', () => ({
+  useHsuIdIdentifier: jest.fn(),
+}));
+
+jest.mock('react-router-dom', () => ({
+  Link: ({ children }) => <div>{children}</div>,
+}));
+
+const mockShowSnackbar = showSnackbar as jest.MockedFunction<typeof showSnackbar>;
+const mockUseConfig = useConfig as jest.MockedFunction<typeof useConfig>;
+const mockUseSession = useSession as jest.MockedFunction<typeof useSession>;
+const mockUseHsuIdIdentifier = useHsuIdIdentifier as jest.MockedFunction<typeof useHsuIdIdentifier>;
+
+describe('PatientSearchHeader - Enforcement Feature', () => {
+  const mockContext = {
+    addPatient: jest.fn(),
+    workflowState: 'NEW_PATIENT',
+    activeFormUuid: 'form-123',
+  };
+
+  const sessionLocation = { uuid: 'loc-session', display: 'General Hospital' };
+  const mismatchedHsuLocation = {
+    location: { uuid: 'loc-other', display: 'Remote Clinic' },
+  };
+
+  beforeEach(() => {
+    mockUseSession.mockReturnValue({ sessionLocation } as Session);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    cleanup();
+  });
+
+  it('triggers an error Snackbar when enforcePatientListLocationMatch is enabled and locations mismatch', async () => {
+    mockUseConfig.mockReturnValue({
+      enforcePatientListLocationMatch: true,
+      patientLocationMismatchCheck: false,
+    } as ConfigSchema);
+
+    mockUseHsuIdIdentifier.mockReturnValue({
+      hsuIdentifier: mismatchedHsuLocation,
+    } as unknown as ReturnType<typeof useHsuIdIdentifier>);
+
+    render(
+      <FormWorkflowContext.Provider value={mockContext as never}>
+        <PatientSearchHeader />
+      </FormWorkflowContext.Provider>,
+    );
+
+    const searchBar = screen.getByTestId('mock-search-select');
+    fireEvent.click(searchBar);
+
+    await waitFor(() => {
+      expect(mockShowSnackbar).toHaveBeenCalledWith(
+        expect.objectContaining({
+          kind: 'error',
+          title: 'Location Mismatch',
+          subtitle: expect.stringContaining('Remote Clinic'),
+        }),
+      );
+    });
+
+    expect(mockContext.addPatient).not.toHaveBeenCalled();
+  });
+
+  it('does NOT trigger snackbar and adds patient if locations match even if enforcement is on', async () => {
+    mockUseConfig.mockReturnValue({
+      enforcePatientListLocationMatch: true,
+    } as ConfigSchema);
+
+    mockUseHsuIdIdentifier.mockReturnValue({
+      hsuIdentifier: { location: { uuid: 'loc-session', display: 'General Hospital' } },
+    } as unknown as ReturnType<typeof useHsuIdIdentifier>);
+
+    render(
+      <FormWorkflowContext.Provider value={mockContext as never}>
+        <PatientSearchHeader />
+      </FormWorkflowContext.Provider>,
+    );
+
+    fireEvent.click(screen.getByTestId('mock-search-select'));
+
+    await waitFor(() => {
+      expect(mockContext.addPatient).toHaveBeenCalledWith('patient-123');
+      expect(mockShowSnackbar).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/form-entry-workflow/patient-search-header/PatientSearchHeader.tsx

@@ -1,5 +1,5 @@
 import { Add, Close } from '@carbon/react/icons';
-import { ExtensionSlot, interpolateUrl, navigate, useConfig, useSession } from '@openmrs/esm-framework';
+import { ExtensionSlot, interpolateUrl, navigate, useConfig, useSession, showSnackbar } from '@openmrs/esm-framework';
 import { Button } from '@carbon/react';
 import React, { useCallback, useContext, useEffect, useState } from 'react';
 import { Link } from 'react-router-dom';
@@ -16,6 +16,7 @@ const PatientSearchHeader = () => {
   const { sessionLocation } = useSession();
   const config = useConfig();
   const { addPatient, workflowState, activeFormUuid } = useContext(FormWorkflowContext);
+  const { t } = useTranslation();
 
   const onPatientMismatchedLocationModalConfirm = useCallback(() => {
     addPatient(selectedPatientUuid);
@@ -34,15 +35,37 @@ const PatientSearchHeader = () => {
   useEffect(() => {
     if (!selectedPatientUuid || !hsuIdentifier) return;
 
-    if (config.patientLocationMismatchCheck && hsuIdentifier && sessionLocation.uuid != hsuIdentifier.location.uuid) {
+    const locationMismatch = sessionLocation.uuid !== hsuIdentifier.location.uuid;
+
+    if (config.enforcePatientListLocationMatch && locationMismatch) {
+      showSnackbar({
+        kind: 'error',
+        title: t('locationMismatch', 'Location Mismatch'),
+        subtitle: t(
+          'patientLocationMismatchEnforced',
+          'Cannot add patient from {{hsuLocation}} to a session at {{sessionLocation}}',
+          {
+            hsuLocation: hsuIdentifier.location?.display,
+            sessionLocation: sessionLocation?.display,
+          },
+        ),
+      });
+      setSelectedPatientUuid(null);
+    } else if (config.patientLocationMismatchCheck && locationMismatch) {
       setPatientLocationMismatchModalOpen(true);
     } else {
       addPatient(selectedPatientUuid);
       setSelectedPatientUuid(null);
     }
-  }, [selectedPatientUuid, sessionLocation, hsuIdentifier, addPatient, config.patientLocationMismatchCheck]);
-
-  const { t } = useTranslation();
+  }, [
+    selectedPatientUuid,
+    sessionLocation,
+    hsuIdentifier,
+    addPatient,
+    config.patientLocationMismatchCheck,
+    config.enforcePatientListLocationMatch,
+    t,
+  ]);
 
   if (workflowState !== 'NEW_PATIENT') return null;
 

package/src/group-form-entry-workflow/group-search-header/GroupSearchHeader.tsx

@@ -1,6 +1,7 @@
 import { Close, Add } from '@carbon/react/icons';
 import { Button } from '@carbon/react';
 import React, { useCallback, useContext, useState } from 'react';
+import { useConfig, useSession, showSnackbar } from '@openmrs/esm-framework';
 import GroupFormWorkflowContext from '../../context/GroupFormWorkflowContext';
 import styles from './styles.scss';
 import { useTranslation } from 'react-i18next';
@@ -9,16 +10,40 @@ import AddGroupModal from '../../add-group-modal/AddGroupModal';
 
 const GroupSearchHeader = () => {
   const { t } = useTranslation();
+  const config = useConfig();
+  const { sessionLocation } = useSession();
   const { activeGroupUuid, setGroup, destroySession } = useContext(GroupFormWorkflowContext);
   const [isOpen, setOpen] = useState(false);
-  const handleSelectGroup = (group) => {
-    group.cohortMembers.sort((a, b) => {
-      const aName = a?.patient?.person?.names?.[0]?.display;
-      const bName = b?.patient?.person?.names?.[0]?.display;
-      return aName.localeCompare(bName, undefined, { sensitivity: 'base' });
-    });
-    setGroup(group);
-  };
+
+  const handleSelectGroup = useCallback(
+    (group) => {
+      if (config.enforcePatientListLocationMatch && group.location && sessionLocation.uuid !== group.location.uuid) {
+        showSnackbar({
+          kind: 'error',
+          title: t('locationMismatch', 'Location Mismatch'),
+          subtitle: t(
+            'groupLocationMismatchEnforced',
+            'Cannot select group from {{groupLocation}} for a session at {{sessionLocation}}',
+            {
+              groupLocation: group.location?.display,
+              sessionLocation: sessionLocation?.display,
+            },
+          ),
+        });
+        return;
+      }
+
+      if (group.cohortMembers) {
+        group.cohortMembers.sort((a, b) => {
+          const aName = a?.patient?.person?.names?.[0]?.display;
+          const bName = b?.patient?.person?.names?.[0]?.display;
+          return aName.localeCompare(bName, undefined, { sensitivity: 'base' });
+        });
+      }
+      setGroup(group);
+    },
+    [config.enforcePatientListLocationMatch, sessionLocation, setGroup, t],
+  );
 
   const handleCancel = useCallback(() => {
     setOpen(false);

package/src/hooks/location-tag.resource.ts

@@ -1,19 +1,6 @@
 import useSWR from 'swr';
 import { openmrsFetch } from '@openmrs/esm-framework';
-
-export interface Identifier {
-  uuid: string;
-  identifier: string;
-  display: string;
-  identifierType: {
-    uuid: string;
-    display: string;
-  };
-  location: {
-    uuid: string;
-    display: string;
-  };
-}
+import { type Identifier } from '../types';
 
 export function useHsuIdIdentifier(patientUuid: string) {
   const hsuIdType = '05a29f94-c0ed-11e2-94be-8c13b969e334';

package/src/hooks/useStartVisit.ts

@@ -1,6 +1,6 @@
 import { useCallback, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { showNotification, showToast, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { showNotification, showSnackbar, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
 
 const useStartVisit = ({ showSuccessNotification = true, showErrorNotification = true }) => {
   const { t } = useTranslation();
@@ -14,10 +14,9 @@ const useStartVisit = ({ showSuccessNotification = true, showErrorNotification =
       setError(false);
       setSuccess(result);
       if (showSuccessNotification) {
-        showToast({
-          critical: true,
+        showSnackbar({
           kind: 'success',
-          description: t('visitStartedSuccessfully', `${result?.data?.visitType?.display} started successfully`),
+          subtitle: t('visitStartedSuccessfully', `${result?.data?.visitType?.display} started successfully`),
           title: t('visitStarted', 'Visit started'),
         });
       }

package/src/types.ts

@@ -23,3 +23,17 @@ export interface SpecificQuestionConfig {
   defaultAnswer?: string;
   disabled?: boolean;
 }
+
+export interface Identifier {
+  uuid: string;
+  identifier: string;
+  display: string;
+  identifierType: {
+    uuid: string;
+    display: string;
+  };
+  location: {
+    uuid: string;
+    display: string;
+  };
+}

package/translations/en.json

@@ -27,8 +27,10 @@
   "formsAppMenuLink": "Fast Data Entry",
   "formsFilled": "Forms filled",
   "goToForm": "Go To Form",
+  "groupLocationMismatchEnforced": "Cannot select group from {{groupLocation}} for a session at {{sessionLocation}}",
   "groupNameError": "Please enter a group name.",
   "identifier": "Identifier",
+  "locationMismatch": "Location Mismatch",
   "markAbsentPatients": "The patients in this group. Patients that are not present in the session should be marked as absent.",
   "members": "members",
   "name": "Name",
@@ -44,6 +46,7 @@
   "orLabelName": "OR label name",
   "patientIsPresent": "Patient is present",
   "patientLocationMismatch": "The selected HSU location ({{hsuLocation}}) does not match the current session location ({{sessionLocation}}). Are you sure you want to proceed?",
+  "patientLocationMismatchEnforced": "Cannot add patient from {{hsuLocation}} to a session at {{sessionLocation}}",
   "patientsInGroup": "Patients in group",
   "postError": "POST Error",
   "practitionerName": "Practitioner Name",