@ampath/esm-patient-registration-app 6.0.1-pre.96 → 9.2.0-next.12

package/src/patient-registration/field/person-attributes/person-attribute-field.test.tsx

@@ -0,0 +1,193 @@
+import React from 'react';
+import { Form, Formik } from 'formik';
+import { render, screen } from '@testing-library/react';
+import { type FieldDefinition } from '../../../config-schema';
+import { usePersonAttributeType } from './person-attributes.resource';
+import { useConceptAnswers } from '../field.resource';
+import { PersonAttributeField } from './person-attribute-field.component';
+
+jest.mock('./person-attributes.resource', () => ({
+  ...jest.requireActual('./person-attributes.resource'),
+  usePersonAttributeType: jest.fn(),
+}));
+
+jest.mock('../field.resource', () => ({
+  ...jest.requireActual('../field.resource'),
+  useConceptAnswers: jest.fn(),
+}));
+
+const mockUsePersonAttributeType = jest.mocked(usePersonAttributeType);
+const mockUseConceptAnswers = jest.mocked(useConceptAnswers);
+
+const mockPersonAttributeType = {
+  format: 'java.lang.String',
+  display: 'Referred by',
+  uuid: '4dd56a75-14ab-4148-8700-1f4f704dc5b0',
+  name: 'Referred by',
+  description: 'The person who referred the patient',
+};
+
+let fieldDefinition: FieldDefinition = {
+  id: 'referredby',
+  label: 'Referred by',
+  type: 'person attribute',
+  uuid: '4dd56a75-14ab-4148-8700-1f4f704dc5b0',
+  answerConceptSetUuid: '6682d17f-0777-45e4-a39b-93f77eb3531c',
+  validation: {
+    matches: '',
+    required: true,
+  },
+  showHeading: true,
+};
+
+describe('PersonAttributeField', () => {
+  beforeEach(() => {
+    mockUsePersonAttributeType.mockReturnValue({
+      data: mockPersonAttributeType,
+      isLoading: false,
+      error: null,
+    });
+  });
+
+  it('renders the text input field for String format', () => {
+    render(
+      <Formik initialValues={{}} onSubmit={() => {}}>
+        <Form>
+          <PersonAttributeField fieldDefinition={fieldDefinition} />
+        </Form>
+      </Formik>,
+    );
+
+    const input = screen.getByLabelText(/Referred by/i) as HTMLInputElement;
+    expect(screen.getByRole('heading')).toBeInTheDocument();
+    expect(input).toBeInTheDocument();
+    expect(input.type).toBe('text');
+  });
+
+  it('should not show heading if showHeading is false', () => {
+    fieldDefinition = {
+      ...fieldDefinition,
+      showHeading: false,
+    };
+
+    render(
+      <Formik initialValues={{}} onSubmit={() => {}}>
+        <Form>
+          <PersonAttributeField fieldDefinition={fieldDefinition} />
+        </Form>
+      </Formik>,
+    );
+
+    expect(screen.queryByRole('heading')).not.toBeInTheDocument();
+  });
+
+  it('renders the coded attribute field for Concept format', () => {
+    fieldDefinition = {
+      id: 'referredby',
+      ...fieldDefinition,
+      label: 'Referred by',
+    };
+
+    mockUsePersonAttributeType.mockReturnValue({
+      data: { ...mockPersonAttributeType, format: 'org.openmrs.Concept' },
+      isLoading: false,
+      error: null,
+    });
+
+    mockUseConceptAnswers.mockReturnValueOnce({
+      data: [
+        { uuid: '1', display: 'Option 1' },
+        { uuid: '2', display: 'Option 2' },
+      ],
+      error: null,
+      isLoading: false,
+    });
+
+    render(
+      <Formik initialValues={{}} onSubmit={() => {}}>
+        <Form>
+          <PersonAttributeField fieldDefinition={fieldDefinition} />
+        </Form>
+      </Formik>,
+    );
+
+    const input = screen.getByLabelText(/Referred by/i) as HTMLInputElement;
+    expect(input).toBeInTheDocument();
+    expect(input.type).toBe('select-one');
+    expect(screen.getByText('Option 1')).toBeInTheDocument();
+    expect(screen.getByText('Option 2')).toBeInTheDocument();
+  });
+
+  it('renders an error notification if attribute type has unknown format', () => {
+    mockUsePersonAttributeType.mockReturnValue({
+      data: { ...mockPersonAttributeType, format: 'unknown' },
+      isLoading: false,
+      error: null,
+    });
+
+    render(
+      <Formik initialValues={{}} onSubmit={() => {}}>
+        <Form>
+          <PersonAttributeField fieldDefinition={fieldDefinition} />
+        </Form>
+      </Formik>,
+    );
+
+    expect(screen.getByText('Error')).toBeInTheDocument();
+    expect(screen.getByText(/Patient attribute type has unknown format/i)).toBeInTheDocument();
+  });
+
+  it('renders an error notification if unable to fetch attribute type', () => {
+    mockUsePersonAttributeType.mockReturnValue({
+      data: null,
+      isLoading: false,
+      error: new Error('Failed to fetch attribute type'),
+    });
+
+    fieldDefinition = {
+      id: 'referredBy',
+      uuid: 'attribute-uuid',
+      label: 'Attribute',
+      showHeading: false,
+      type: 'person attribute',
+    };
+
+    render(
+      <Formik initialValues={{}} onSubmit={() => {}}>
+        <Form>
+          <PersonAttributeField fieldDefinition={fieldDefinition} />
+        </Form>
+      </Formik>,
+    );
+
+    expect(screen.getByText('Error')).toBeInTheDocument();
+    expect(screen.getByText(/Unable to fetch person attribute type/i)).toBeInTheDocument();
+  });
+
+  it('renders a skeleton if attribute type is loading', async () => {
+    mockUsePersonAttributeType.mockReturnValue({
+      data: null,
+      isLoading: true,
+      error: null,
+    });
+
+    fieldDefinition = {
+      id: 'referredBy',
+      uuid: 'attribute-uuid',
+      label: 'Attribute',
+      showHeading: true,
+      type: 'person attribute',
+    };
+
+    render(
+      <Formik initialValues={{}} onSubmit={() => {}}>
+        <Form>
+          <PersonAttributeField fieldDefinition={fieldDefinition} />
+        </Form>
+      </Formik>,
+    );
+
+    await screen.findByRole('heading', { name: /attribute/i });
+    expect(screen.queryByLabelText(/referred by/i)).not.toBeInTheDocument();
+  });
+});

package/src/patient-registration/field/person-attributes/text-person-attribute-field.test.tsx

@@ -0,0 +1,90 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Form, Formik } from 'formik';
+import { TextPersonAttributeField } from './text-person-attribute-field.component';
+
+describe('TextPersonAttributeField', () => {
+  const mockPersonAttributeType = {
+    format: 'java.lang.String',
+    display: 'Referred by',
+    uuid: '4dd56a75-14ab-4148-8700-1f4f704dc5b0',
+    description: 'Referred by',
+    name: 'Referred by',
+  };
+
+  it('renders the input field with a label', () => {
+    render(
+      <Formik initialValues={{}} onSubmit={() => {}}>
+        <Form>
+          <TextPersonAttributeField
+            id="attributeId"
+            personAttributeType={mockPersonAttributeType}
+            label="Custom Label"
+          />
+        </Form>
+      </Formik>,
+    );
+
+    expect(screen.getByRole('textbox', { name: /custom label \(optional\)/i })).toBeInTheDocument();
+  });
+
+  it('renders the input field with the default label if label prop is not provided', () => {
+    render(
+      <Formik initialValues={{}} onSubmit={() => {}}>
+        <Form>
+          <TextPersonAttributeField id="attributeId" personAttributeType={mockPersonAttributeType} />
+        </Form>
+      </Formik>,
+    );
+
+    expect(screen.getByRole('textbox', { name: /referred by \(optional\)/i })).toBeInTheDocument();
+  });
+
+  it('validates the input with the provided validationRegex', async () => {
+    const user = userEvent.setup();
+    const validationRegex = '^[A-Z]+$'; // Accepts only uppercase letters
+
+    render(
+      <Formik initialValues={{}} onSubmit={() => {}}>
+        <Form>
+          <TextPersonAttributeField
+            id="attributeId"
+            personAttributeType={mockPersonAttributeType}
+            validationRegex={validationRegex}
+          />
+        </Form>
+      </Formik>,
+    );
+
+    const textbox = screen.getByRole('textbox', { name: /referred by \(optional\)/i });
+    expect(textbox).toBeInTheDocument();
+
+    // Valid input: "ABC"
+    await user.type(textbox, 'ABC');
+    await user.tab();
+
+    expect(screen.queryByText(/invalid input/i)).not.toBeInTheDocument();
+    await user.clear(textbox);
+
+    // // Invalid input: "abc" (contains lowercase letters)
+    await user.type(textbox, 'abc');
+    await user.tab();
+    expect(screen.getByText(/invalid input/i)).toBeInTheDocument();
+  });
+
+  it('renders the input field as required when required prop is true', () => {
+    render(
+      <Formik initialValues={{}} onSubmit={() => {}}>
+        <Form>
+          <TextPersonAttributeField id="attributeId" personAttributeType={mockPersonAttributeType} required />
+        </Form>
+      </Formik>,
+    );
+    const textbox = screen.getByRole('textbox', { name: /referred by/i });
+
+    // Required attribute should be truthy on the input element
+    expect(textbox).toBeInTheDocument();
+    expect(textbox).toBeRequired();
+  });
+});

package/src/patient-registration/form-manager.test.ts

@@ -0,0 +1,91 @@
+import { FormManager } from './form-manager';
+import { type FormValues } from './patient-registration.types';
+import { generateIdentifier } from './patient-registration.resource';
+
+jest.mock('./patient-registration.resource', () => ({
+  ...jest.requireActual('./patient-registration.resource'),
+  generateIdentifier: jest.fn(),
+}));
+
+const mockGenerateIdentifier = generateIdentifier as jest.Mock;
+
+const formValues: FormValues = {
+  patientUuid: '',
+  givenName: '',
+  middleName: '',
+  familyName: '',
+  additionalGivenName: '',
+  additionalMiddleName: '',
+  additionalFamilyName: '',
+  addNameInLocalLanguage: false,
+  gender: '',
+  birthdate: '',
+  yearsEstimated: 1000,
+  monthsEstimated: 11,
+  birthdateEstimated: false,
+  telephoneNumber: '',
+  isDead: false,
+  deathDate: 'string',
+  deathTime: '',
+  deathTimeFormat: 'AM',
+  deathCause: 'string',
+  nonCodedCauseOfDeath: '',
+  relationships: [],
+  address: {
+    address1: '',
+    address2: '',
+    cityVillage: '',
+    stateProvince: 'New York',
+    country: 'string',
+    postalCode: 'string',
+  },
+  identifiers: {
+    foo: {
+      identifierUuid: 'aUuid',
+      identifierName: 'Foo',
+      required: false,
+      initialValue: 'foo',
+      identifierValue: 'foo',
+      identifierTypeUuid: 'identifierType',
+      preferred: true,
+      autoGeneration: false,
+      selectedSource: {
+        uuid: 'some-uuid',
+        name: 'unique',
+        autoGenerationOption: { manualEntryEnabled: true, automaticGenerationEnabled: false },
+      },
+    },
+  },
+};
+
+describe('FormManager', () => {
+  describe('createIdentifiers', () => {
+    it('uses the uuid of a field name if it exists', async () => {
+      const result = await FormManager.savePatientIdentifiers(true, undefined, formValues.identifiers, {}, 'Nyc');
+      expect(result).toEqual([
+        {
+          uuid: 'aUuid',
+          identifier: 'foo',
+          identifierType: 'identifierType',
+          location: 'Nyc',
+          preferred: true,
+        },
+      ]);
+    });
+
+    it('should generate identifier if it has autoGeneration and manual entry disabled', async () => {
+      formValues.identifiers.foo.autoGeneration = true;
+      formValues.identifiers.foo.selectedSource.autoGenerationOption.manualEntryEnabled = false;
+      mockGenerateIdentifier.mockResolvedValue({ data: { identifier: '10001V' } });
+      await FormManager.savePatientIdentifiers(true, undefined, formValues.identifiers, {}, 'Nyc');
+      expect(mockGenerateIdentifier.mock.calls).toHaveLength(1);
+    });
+
+    it('should not generate identifiers if manual entry enabled and identifier value given', async () => {
+      formValues.identifiers.foo.autoGeneration = true;
+      formValues.identifiers.foo.selectedSource.autoGenerationOption.manualEntryEnabled = true;
+      await FormManager.savePatientIdentifiers(true, undefined, formValues.identifiers, {}, 'Nyc');
+      expect(mockGenerateIdentifier.mock.calls).toHaveLength(0);
+    });
+  });
+});

package/src/patient-registration/form-manager.ts

@@ -1,35 +1,39 @@
 import {
   type FetchResponse,
+  getConfig,
   openmrsFetch,
   queueSynchronizationItem,
-  type Session,
   restBaseUrl,
-  getConfig,
+  type Session,
+  type StyleguideConfigObject,
+  toOmrsIsoString,
 } from '@openmrs/esm-framework';
 import { patientRegistration } from '../constants';
 import {
-  type FormValues,
   type AttributeValue,
-  type PatientUuidMapType,
-  type Patient,
   type CapturePhotoProps,
+  type Encounter,
+  type FormValues,
+  type Patient,
   type PatientIdentifier,
   type PatientRegistration,
+  type PatientUuidMapType,
   type RelationshipValue,
-  type Encounter,
 } from './patient-registration.types';
 import {
   addPatientIdentifier,
   deletePatientIdentifier,
   deletePersonName,
   deleteRelationship,
+  generateAmrsUniversalIdentifier,
   generateIdentifier,
+  getDatetime,
+  saveEncounter,
   savePatient,
   savePatientPhoto,
   saveRelationship,
-  updateRelationship,
   updatePatientIdentifier,
-  saveEncounter,
+  updateRelationship,
 } from './patient-registration.resource';
 import { type RegistrationConfig } from '../config-schema';
 
@@ -61,7 +65,7 @@ export class FormManager {
   ) => {
     const syncItem: PatientRegistration = {
       fhirPatient: FormManager.mapPatientToFhirPatient(
-        FormManager.getPatientToCreate(isNewPatient, values, patientUuidMap, initialAddressFieldValues, []),
+        FormManager.getPatientToCreate(isNewPatient, values, patientUuidMap, initialAddressFieldValues, [], config),
       ),
       _patientRegistrationData: {
         isNewPatient,
@@ -114,6 +118,7 @@ export class FormManager {
       patientUuidMap,
       initialAddressFieldValues,
       patientIdentifiers,
+      config,
     );
 
     FormManager.getDeletedNames(values.patientUuid, patientUuidMap).forEach(async (name) => {
@@ -131,14 +136,15 @@ export class FormManager {
 
       await this.saveObservations(values.obs, savePatientResponse, currentLocation, currentUser, config);
 
-      const { patientPhotoUuid } = await getConfig('@openmrs/esm-styleguide');
-      if (patientPhotoUuid && capturePhotoProps?.imageData) {
+      const { patientPhotoConceptUuid } = await getConfig<StyleguideConfigObject>('@openmrs/esm-styleguide');
+
+      if (patientPhotoConceptUuid && capturePhotoProps?.imageData) {
         await savePatientPhoto(
           savePatientResponse.data.uuid,
           capturePhotoProps.imageData,
           `${restBaseUrl}/obs`,
           capturePhotoProps.dateTime || new Date().toISOString(),
-          patientPhotoUuid,
+          patientPhotoConceptUuid,
         );
       }
     }
@@ -189,6 +195,7 @@ export class FormManager {
         );
       } else {
         const encounterToSave: Encounter = {
+          encounterDatetime: new Date(),
           patient: savePatientResponse.data.uuid,
           encounterType: config.registrationObs.encounterTypeUuid,
           location: currentLocation,
@@ -234,11 +241,19 @@ export class FormManager {
           initialValue,
         } = patientIdentifier;
 
-        const identifier = !autoGeneration
-          ? identifierValue
-          : await (
-              await generateIdentifier(selectedSource.uuid)
-            ).data.identifier;
+        const autoGenerationManualEntry =
+          autoGeneration && selectedSource?.autoGenerationOption?.manualEntryEnabled && !!identifierValue;
+        let identifier;
+        if (identifierTypeUuid === '58a4732e-1359-11df-a1f1-0026b9348838') {
+          identifier = await generateAmrsUniversalIdentifier();
+        } else {
+          identifier =
+            !autoGeneration || autoGenerationManualEntry
+              ? identifierValue
+              : await (
+                  await generateIdentifier(selectedSource.uuid)
+                ).data.identifier;
+        }
         const identifierToCreate = {
           uuid: identifierUuid,
           identifier,
@@ -294,6 +309,7 @@ export class FormManager {
     patientUuidMap: PatientUuidMapType,
     initialAddressFieldValues: Record<string, any>,
     identifiers: Array<PatientIdentifier>,
+    config?: RegistrationConfig,
   ): Patient {
     let birthdate;
     if (values.birthdate instanceof Date) {
@@ -314,7 +330,7 @@ export class FormManager {
         birthdateEstimated: values.birthdateEstimated,
         attributes: FormManager.getPatientAttributes(isNewPatient, values, patientUuidMap),
         addresses: [values.address],
-        ...FormManager.getPatientDeathInfo(values),
+        ...FormManager.getPatientDeathInfo(values, config),
       },
       identifiers,
     };
@@ -373,12 +389,22 @@ export class FormManager {
     return attributes;
   }
 
-  static getPatientDeathInfo(values: FormValues) {
-    const { isDead, deathDate, deathCause } = values;
+  static getPatientDeathInfo(values: FormValues, config?: RegistrationConfig) {
+    const { isDead, deathDate, deathTime, deathTimeFormat, deathCause, nonCodedCauseOfDeath } = values;
+
+    if (!isDead) {
+      return {
+        dead: false,
+      };
+    }
+    const dateTimeOfDeath = toOmrsIsoString(getDatetime(deathDate, deathTime, deathTimeFormat));
+
     return {
-      dead: isDead,
-      deathDate: isDead ? deathDate : undefined,
-      causeOfDeath: isDead ? deathCause : undefined,
+      dead: true,
+      deathDate: dateTimeOfDeath,
+      ...(deathCause === config?.freeTextFieldConceptUuid
+        ? { causeOfDeathNonCoded: nonCodedCauseOfDeath, causeOfDeath: null }
+        : { causeOfDeath: deathCause, causeOfDeathNonCoded: null }),
     };
   }
 

package/src/patient-registration/input/basic-input/input/input.component.tsx

@@ -66,7 +66,7 @@ export interface TextInputProps
    * `true` to use the light version. For use on $ui-01 backgrounds only.
    * Don't use this to make tile background color same as container background color.
    * 'The `light` prop for `TextInput` has ' +
-      'been deprecated in favor of the new `Layer` component. It will be removed in the next major release.'
+   'been deprecated in favor of the new `Layer` component. It will be removed in the next major release.'
    */
   light?: boolean;
 
@@ -145,10 +145,14 @@ export const Input: React.FC<InputProps> = ({ checkWarning, ...props }) => {
     t('invalidEmail')
     t('numberInNameDubious')
     t('yearsEstimateRequired')
+    t('deathdayIsRequired', 'Death date is required when the patient is marked as deceased.')
+    t('deathdayInvalidDate', 'Date of death is invalid')
+    t('deathCauseRequired', 'Cause of death is required')
+    t('nonCodedCauseOfDeathRequired', 'Non-coded cause of death is required')
   */
 
   const value = field.value || '';
-  const invalidText = meta.error && t(meta.error);
+  const invalidText = meta.error || '';
   const warnText = useMemo(() => {
     if (!invalidText && typeof checkWarning === 'function') {
       const warning = checkWarning(value);

package/src/patient-registration/input/basic-input/select/select-input.test.tsx

@@ -0,0 +1,49 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Formik, Form } from 'formik';
+import { SelectInput } from './select-input.component';
+
+describe('the select input', () => {
+  const setupSelect = async () => {
+    render(
+      <Formik initialValues={{ select: '' }} onSubmit={null}>
+        <Form>
+          <SelectInput label="Select" name="select" options={['A Option', 'B Option']} required />
+        </Form>
+      </Formik>,
+    );
+    return screen.getByLabelText('Select') as HTMLInputElement;
+  };
+
+  it('exists', async () => {
+    const input = await setupSelect();
+    expect(input.type).toEqual('select-one');
+  });
+
+  it('can input data', async () => {
+    const user = userEvent.setup();
+    const input = await setupSelect();
+    const expected = 'A Option';
+
+    await user.selectOptions(input, expected);
+
+    await expect(input.value).toEqual(expected);
+  });
+
+  it('should show optional label if the input is not required', async () => {
+    render(
+      <Formik initialValues={{ select: '' }} onSubmit={null}>
+        <Form>
+          <SelectInput label="Select" name="select" options={['A Option', 'B Option']} />
+        </Form>
+      </Formik>,
+    );
+
+    await screen.findByRole('combobox');
+
+    const selectInput = screen.getByRole('combobox', { name: 'Select (optional)' }) as HTMLSelectElement;
+    expect(selectInput.labels).toHaveLength(1);
+    expect(selectInput.labels[0]).toHaveTextContent('Select (optional)');
+  });
+});

package/src/patient-registration/input/custom-input/autosuggest/autosuggest.scss

@@ -1,6 +1,6 @@
-@use '@carbon/styles/scss/spacing';
-@use '@carbon/styles/scss/type';
-@import '~@openmrs/esm-styleguide/src/vars';
+@use '@carbon/layout';
+@use '@carbon/type';
+@use '@openmrs/esm-styleguide/src/vars' as *;
 
 .label01 {
   @include type.type-style('label-01');
@@ -18,12 +18,12 @@
   position: absolute;
   left: 0;
   background-color: #fff;
-  margin-bottom: 20px;
+  margin-bottom: 1.25rem;
   z-index: 99;
 }
 
 .suggestions li {
-  padding: spacing.$spacing-05;
+  padding: layout.$spacing-05;
   line-height: 1.29;
   color: #525252;
   border-bottom: 1px solid #8d8d8d;