@openmrs/esm-patient-registration-app 3.0.2-pre.310 → 3.0.2-pre.332

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

@@ -1,8 +1,10 @@
 import FormManager from './form-manager';
+import { FormValues } from './patient-registration-types';
 
 jest.mock('./patient-registration.resource');
 
-const formValues = {
+const formValues: FormValues = {
+  patientUuid: '',
   givenName: '',
   middleName: '',
   familyName: '',
@@ -42,20 +44,9 @@ const identifierSource = {
 describe('FormManager', () => {
   describe('createIdentifiers', () => {
     it('uses the uuid of a field name if it exists', async () => {
-      const result = await FormManager.getPatientIdentifiersToCreate(
+      const result = await FormManager.savePatientIdentifiers(
+        undefined,
         formValues.identifiers,
-        [
-          {
-            name: 'foo',
-            required: false,
-            isPrimary: true,
-            fieldName: 'givenName',
-            uuid: 'identifierType',
-            format: 'n/a',
-            autoGenerationSource: identifierSource,
-            identifierSources: [],
-          },
-        ],
         'Nyc',
         new AbortController(),
       );

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

@@ -10,6 +10,7 @@ import {
   CapturePhotoProps,
   PatientIdentifier,
   PatientIdentifierValue,
+  PatientRegistration,
 } from './patient-registration-types';
 import {
   addPatientIdentifier,
@@ -24,7 +25,7 @@ import {
 import isEqual from 'lodash-es/isEqual';
 
 export type SavePatientForm = (
-  patientUuid: string | undefined,
+  isNewPatient: boolean,
   values: FormValues,
   patientUuidMap: PatientUuidMapType,
   initialAddressFieldValues: Record<string, any>,
@@ -38,7 +39,7 @@ export type SavePatientForm = (
 
 export default class FormManager {
   static async savePatientFormOffline(
-    patientUuid = v4(),
+    isNewPatient: boolean,
     values: FormValues,
     patientUuidMap: PatientUuidMapType,
     initialAddressFieldValues: Record<string, any>,
@@ -48,10 +49,12 @@ export default class FormManager {
     currentLocation: string,
     personAttributeSections: any,
   ): Promise<null> {
-    await queueSynchronizationItem(
-      patientRegistration,
-      {
-        patientUuid,
+    const syncItem: PatientRegistration = {
+      fhirPatient: FormManager.mapPatientToFhirPatient(
+        FormManager.getPatientToCreate(values, personAttributeSections, patientUuidMap, initialAddressFieldValues, []),
+      ),
+      _patientRegistrationData: {
+        isNewPatient,
         formValues: values,
         patientUuidMap,
         initialAddressFieldValues,
@@ -61,18 +64,19 @@ export default class FormManager {
         currentLocation,
         personAttributeSections,
       },
-      {
-        id: patientUuid,
-        displayName: 'Patient registration',
-        dependencies: [],
-      },
-    );
+    };
+
+    await queueSynchronizationItem(patientRegistration, syncItem, {
+      id: values.patientUuid,
+      displayName: 'Patient registration',
+      dependencies: [],
+    });
 
     return null;
   }
 
   static async savePatientFormOnline(
-    patientUuid: string | undefined,
+    isNewPatient: boolean,
     values: FormValues,
     patientUuidMap: PatientUuidMapType,
     initialAddressFieldValues: Record<string, any>,
@@ -83,19 +87,13 @@ export default class FormManager {
     personAttributeSections: any,
     abortController: AbortController,
   ): Promise<string> {
-    const patientIdentifiers: PatientIdentifier[] = await FormManager.getPatientIdentifiersToCreate(
+    const patientIdentifiers: Array<PatientIdentifier> = await FormManager.savePatientIdentifiers(
+      values.patientUuid,
       values.identifiers,
-      identifierTypes,
       currentLocation,
       abortController,
     );
 
-    if (patientUuid) {
-      await Promise.all(
-        FormManager.savePatientIdentifiers(patientUuid, patientIdentifiers, values.identifiers, abortController),
-      );
-    }
-
     const createdPatient = FormManager.getPatientToCreate(
       values,
       personAttributeSections,
@@ -104,11 +102,15 @@ export default class FormManager {
       patientIdentifiers,
     );
 
-    FormManager.getDeletedNames(patientUuidMap).forEach(async (name) => {
+    FormManager.getDeletedNames(values.patientUuid, patientUuidMap).forEach(async (name) => {
       await deletePersonName(name.nameUuid, name.personUuid, abortController);
     });
 
-    const savePatientResponse = await savePatient(abortController, createdPatient, patientUuidMap.patientUuid);
+    const savePatientResponse = await savePatient(
+      abortController,
+      createdPatient,
+      isNewPatient ? undefined : values.patientUuid,
+    );
 
     if (savePatientResponse.ok) {
       await Promise.all(
@@ -144,41 +146,39 @@ export default class FormManager {
     return savePatientResponse.data.uuid;
   }
 
-  static getPatientIdentifiersToCreate(
-    patientIdentifiers: PatientIdentifierValue[], // values.identifiers
-    identifierTypes: Array<PatientIdentifierType>,
+  static async savePatientIdentifiers(
+    patientUuid: string,
+    patientIdentifiers: Array<PatientIdentifierValue>, // values.identifiers
     location: string,
     abortController: AbortController,
   ): Promise<Array<PatientIdentifier>> {
-    const identifierTypeRequests: Array<Promise<PatientIdentifier>> = patientIdentifiers.map(
-      async (patientIdentifier) => {
-        const { identifierType: identifierTypeUuid, identifier, uuid, action, source } = patientIdentifier;
-        const identifierType = identifierTypes.find((identifierType) => identifierType.uuid === identifierTypeUuid);
-        if (identifier) {
-          return {
+    let identifierTypeRequests = patientIdentifiers
+      .filter((identifier) => identifier.action !== 'DELETE' && identifier.action !== 'NONE')
+      .map(async (patientIdentifier) => {
+        const { identifierTypeUuid, identifier, uuid, action, source, preferred, autoGeneration } = patientIdentifier;
+        if (identifier || (source && autoGeneration)) {
+          const identifierValue = identifier
+            ? identifier
+            : await (
+                await generateIdentifier(patientIdentifier.source.uuid, abortController)
+              ).data.identifier;
+          const identifierToCreate = {
             uuid,
-            identifier,
+            identifier: identifierValue,
             identifierType: identifierTypeUuid,
-            location: location,
-            preferred: identifierType?.isPrimary,
-          };
-        } else if (source && patientIdentifier?.autoGeneration) {
-          const generateIdentifierResponse = await generateIdentifier(patientIdentifier.source.uuid, abortController);
-          return {
-            // is this undefined?
-            uuid,
-            identifier: generateIdentifierResponse.data.identifier,
-            identifierType: identifierTypeUuid,
-            location: location,
-            preferred: identifierType?.isPrimary,
-          };
-        } else if (action === 'DELETE') {
-          return {
-            uuid,
-            identifier: identifierTypeUuid,
             location,
-            preferred: identifierType.isPrimary,
+            preferred,
           };
+
+          if (patientUuid) {
+            if (action === 'ADD') {
+              await addPatientIdentifier(patientUuid, identifierToCreate, abortController);
+            } else if (action === 'UPDATE') {
+              await updatePatientIdentifier(patientUuid, uuid, identifierToCreate.identifier, abortController);
+            }
+          }
+
+          return identifierToCreate;
         } else {
           // This is a case that should not occur.
           // If it did, the subsequent network request (when creating the patient) would fail with
@@ -186,18 +186,26 @@ export default class FormManager {
           // Better stop early.
           throw new Error('No approach for generating a patient identifier could be found.');
         }
-      },
-    );
+      });
+
+    if (patientUuid) {
+      patientIdentifiers
+        .filter((patientIdentifier) => patientIdentifier.action === 'DELETE')
+        .forEach(
+          async (patientIdentifier) =>
+            await deletePatientIdentifier(patientUuid, patientIdentifier.uuid, abortController),
+        );
+    }
 
     return Promise.all(identifierTypeRequests);
   }
 
-  static getDeletedNames(patientUuidMap: PatientUuidMapType) {
+  static getDeletedNames(patientUuid: string, patientUuidMap: PatientUuidMapType) {
     if (patientUuidMap?.additionalNameUuid) {
       return [
         {
           nameUuid: patientUuidMap.additionalNameUuid,
-          personUuid: patientUuidMap.patientUuid,
+          personUuid: patientUuid,
         },
       ];
     }
@@ -218,9 +226,9 @@ export default class FormManager {
     }
 
     return {
-      uuid: patientUuidMap['patientUuid'],
+      uuid: values.patientUuid,
       person: {
-        uuid: patientUuidMap['patientUuid'],
+        uuid: values.patientUuid,
         names: FormManager.getNames(values, patientUuidMap),
         gender: values.gender.charAt(0),
         birthdate: values.birthdate,
@@ -293,20 +301,44 @@ export default class FormManager {
     };
   }
 
-  static savePatientIdentifiers(
-    patientUuid: string,
-    patientIdentifiers: PatientIdentifier[],
-    identifiers: PatientIdentifierValue[],
-    abortController: AbortController,
-  ) {
-    return identifiers.map((identifier, index) => {
-      if (identifier.action === 'ADD') {
-        return addPatientIdentifier(patientUuid, patientIdentifiers[index], abortController);
-      } else if (identifier.action === 'UPDATE') {
-        return updatePatientIdentifier(patientUuid, patientIdentifiers[index], abortController);
-      } else if (identifier.action === 'DELETE') {
-        deletePatientIdentifier(patientUuid, patientIdentifiers[index]?.uuid, abortController);
-      }
-    });
+  static mapPatientToFhirPatient(patient: Partial<Patient>): fhir.Patient {
+    // Important:
+    // When changing this code, ideally assume that `patient` can be missing any attribute.
+    // The `fhir.Patient` provides us with the benefit that all properties are nullable and thus
+    // not required (technically, at least). -> Even if we cannot map some props here, we still
+    // provide a valid fhir.Patient object. The various patient chart modules should be able to handle
+    // such missing props correctly (and should be updated if they don't).
+
+    // Gender in the original object only uses a single letter. fhir.Patient expects a full string.
+    const genderMap = {
+      M: 'male',
+      F: 'female',
+      O: 'other',
+      U: 'unknown',
+    };
+
+    // Mapping inspired by:
+    // https://github.com/openmrs/openmrs-module-fhir/blob/669b3c52220bb9abc622f815f4dc0d8523687a57/api/src/main/java/org/openmrs/module/fhir/api/util/FHIRPatientUtil.java#L36
+    // https://github.com/openmrs/openmrs-esm-patient-management/blob/94e6f637fb37cf4984163c355c5981ea6b8ca38c/packages/esm-patient-search-app/src/patient-search-result/patient-search-result.component.tsx#L21
+    // Update as required.
+    return {
+      id: patient.uuid,
+      gender: genderMap[patient.person?.gender],
+      birthDate: patient.person?.birthdate,
+      deceasedBoolean: patient.person.dead,
+      deceasedDateTime: patient.person.deathDate,
+      name: patient.person?.names?.map((name) => ({
+        given: [name.givenName, name.middleName].filter(Boolean),
+        family: name.familyName,
+      })),
+      address: patient.person?.addresses.map((address) => ({
+        city: address.cityVillage,
+        country: address.country,
+        postalCode: address.postalCode,
+        state: address.stateProvince,
+        use: 'home',
+      })),
+      telecom: patient.person.attributes?.filter((attribute) => attribute.attributeType === 'Telephone Number'),
+    };
   }
 }

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

@@ -1,15 +1,9 @@
 import React, { useMemo } from 'react';
-import { TextInput } from 'carbon-components-react';
+import { TextInput, TextInputProps } from 'carbon-components-react';
 import { useField } from 'formik';
 import { useTranslation } from 'react-i18next';
 
-interface InputProps {
-  id: string;
-  name: string;
-  labelText: string;
-  light: boolean;
-  disabled?: boolean;
-  placeholder?: string;
+interface InputProps extends TextInputProps {
   checkWarning?(value: string): string;
 }
 

package/src/patient-registration/input/custom-input/identifier/identifier-input.component.tsx

@@ -1,13 +1,13 @@
-import * as Yup from 'yup';
 import React, { useState, useEffect, useCallback, useContext, useMemo } from 'react';
 import styles from '../../input.scss';
 import { useTranslation } from 'react-i18next';
 import { Input } from '../../basic-input/input/input.component';
 import { PatientIdentifierValue } from '../../../patient-registration-types';
 import { PatientRegistrationContext } from '../../../patient-registration-context';
-import { TrashCan16, Edit16, Undo16 } from '@carbon/icons-react';
+import { TrashCan16, Edit16 } from '@carbon/icons-react';
 import { Button } from 'carbon-components-react';
 import { ResourcesContext } from '../../../../offline.resources';
+import { showModal } from '@openmrs/esm-framework';
 
 interface IdentifierInputProps {
   patientIdentifier: PatientIdentifierValue;
@@ -16,23 +16,21 @@ interface IdentifierInputProps {
 }
 
 export const IdentifierInput: React.FC<IdentifierInputProps> = ({ patientIdentifier, index, remove }) => {
-  const { patientIdentifiers: identifierTypes } = useContext(ResourcesContext);
+  const { identifierTypes } = useContext(ResourcesContext);
   const identifierType = useMemo(
-    () => identifierTypes.find((identifierType) => identifierType.uuid === patientIdentifier.identifierType),
-    [patientIdentifier],
+    () => identifierTypes.find((identifierType) => identifierType.uuid === patientIdentifier.identifierTypeUuid),
+    [patientIdentifier, identifierTypes],
   );
-  const { validationSchema, setValidationSchema, setFieldValue, values } = React.useContext(PatientRegistrationContext);
+
+  const { setFieldValue } = React.useContext(PatientRegistrationContext);
   const { source, action, identifier } = patientIdentifier;
-  const identifierName = identifierType.name;
+  const identifierName = identifierType?.name;
   const fieldName = `identifiers[${index}].identifier`;
   const { t } = useTranslation();
   const [option, setAutoGenerationOption] = useState({
     manualEntryEnabled: source ? true : undefined,
     automaticGenerationEnabled: undefined,
   });
-  const [identifierValidationSchema, setIdentifierValidationSchema] = useState(Yup.object({}));
-  // This will save the value, if value is to be restored is needed
-  const [restoredValue, setRestoredValue] = useState(patientIdentifier.identifier);
 
   useEffect(() => {
     if (source && source.autoGenerationOption && source.autoGenerationOption.automaticGenerationEnabled) {
@@ -61,16 +59,15 @@ export const IdentifierInput: React.FC<IdentifierInputProps> = ({ patientIdentif
         manualEntryEnabled: true,
         automaticGenerationEnabled: false,
       });
-      setFieldValue(`identifiers[${index}].autoGeneration`, true);
+      setFieldValue(`identifiers[${index}].autoGeneration`, false);
     }
   }, [source]);
 
   const handleEdit = useCallback(() => {
-    setRestoredValue(patientIdentifier.identifier);
     setFieldValue(`identifiers[${index}]`, {
       ...patientIdentifier,
       action: 'UPDATE',
-      source: identifierType.identifierSources.length > 0 ? identifierType.identifierSources[0] : null,
+      source: identifierType?.identifierSources?.[0],
     } as PatientIdentifierValue);
   }, [patientIdentifier]);
 
@@ -78,18 +75,18 @@ export const IdentifierInput: React.FC<IdentifierInputProps> = ({ patientIdentif
     if (action === 'ADD') {
       remove(index);
     } else {
-      setFieldValue(`identifiers[${index}].action`, 'DELETE');
+      const confirmDeleteIdentifierModal = showModal('delete-identifier-confirmation-modal', {
+        deleteIdentifier: (deleteIdentifier) => {
+          if (deleteIdentifier) {
+            setFieldValue(`identifiers[${index}].action`, 'DELETE');
+          }
+          confirmDeleteIdentifierModal();
+        },
+        identifierName,
+        identifierValue: identifier,
+      });
     }
-  }, [patientIdentifier]);
-
-  const handleUndo = useCallback(() => {
-    setFieldValue(`identifiers[${index}]`, {
-      ...patientIdentifier,
-      action: 'NONE',
-      source: null,
-      identifier: restoredValue,
-    } as PatientIdentifierValue);
-  }, [patientIdentifier, restoredValue]);
+  }, [action, patientIdentifier, identifierName, identifier]);
 
   const autoGenerated = !option.manualEntryEnabled || (option.manualEntryEnabled && option.automaticGenerationEnabled);
 
@@ -107,6 +104,7 @@ export const IdentifierInput: React.FC<IdentifierInputProps> = ({ patientIdentif
           labelText={identifierName}
           name={fieldName}
           disabled={!option.manualEntryEnabled}
+          required
         />
       ) : (
         <div className={styles.textID}>
@@ -117,16 +115,7 @@ export const IdentifierInput: React.FC<IdentifierInputProps> = ({ patientIdentif
         </div>
       )}
       <div>
-        {patientIdentifier.action === 'UPDATE' && (
-          <Button
-            kind="ghost"
-            onClick={handleUndo}
-            iconDescription={t('restoreIdentifierTooltip', 'Restore')}
-            hasIconOnly>
-            <Undo16 />
-          </Button>
-        )}
-        {patientIdentifier.action === 'NONE' && (
+        {!(identifierType.isPrimary || identifierType.required) && patientIdentifier.action === 'NONE' && (
           <Button kind="ghost" onClick={handleEdit} iconDescription={t('editIdentifierTooltip', 'Edit')} hasIconOnly>
             <Edit16 />
           </Button>

package/src/patient-registration/input/dummy-data/dummy-data-input.component.tsx

@@ -1,4 +1,5 @@
 import React from 'react';
+import { v4 } from 'uuid';
 import { FormValues } from '../../patient-registration-types';
 import styles from './../input.scss';
 
@@ -7,6 +8,7 @@ interface DummyDataInputProps {
 }
 
 export const dummyFormValues: FormValues = {
+  patientUuid: v4(),
   givenName: 'John',
   middleName: '',
   familyName: 'Smith',

package/src/patient-registration/patient-registration-hooks.ts

@@ -1,71 +1,81 @@
 import { getSynchronizationItems, usePatient } from '@openmrs/esm-framework';
 import { Dispatch, useEffect, useState } from 'react';
+import { v4 } from 'uuid';
 import { patientRegistration } from '../constants';
-import {
-  FormValues,
-  PatientIdentifierValue,
-  PatientRegistration,
-  PatientUuidMapType,
-} from './patient-registration-types';
+import { FormValues, PatientRegistration, PatientUuidMapType } from './patient-registration-types';
 import {
   getAddressFieldValuesFromFhirPatient,
   getFormValuesFromFhirPatient,
-  getPatientIdentifiers,
+  getInitialPatientIdentifiers,
   getPatientUuidMapFromFhirPatient,
   getPhonePersonAttributeValueFromFhirPatient,
 } from './patient-registration-utils';
 
-const blankFormValues: FormValues = {
-  givenName: '',
-  middleName: '',
-  familyName: '',
-  unidentifiedPatient: false,
-  additionalGivenName: '',
-  additionalMiddleName: '',
-  additionalFamilyName: '',
-  addNameInLocalLanguage: false,
-  gender: '',
-  birthdate: null,
-  yearsEstimated: 0,
-  monthsEstimated: 0,
-  birthdateEstimated: false,
-  telephoneNumber: '',
-  address1: '',
-  address2: '',
-  cityVillage: '',
-  stateProvince: '',
-  country: '',
-  postalCode: '',
-  isDead: false,
-  deathDate: '',
-  deathCause: '',
-  relationships: [{ relatedPerson: '', relationship: '' }],
-  identifiers: [],
-};
-
-export function useInitialFormValues(
-  patientUuid: string,
-  fallback = blankFormValues,
-): [FormValues, Dispatch<FormValues>] {
-  const { isLoading, patient } = usePatient(patientUuid);
-  const [initialFormValues, setInitialFormValues] = useState<FormValues>(fallback);
+export function useInitialFormValues(patientUuid: string): [FormValues, Dispatch<FormValues>] {
+  const { isLoading: isLoadingPatientToEdit, patient: patientToEdit } = usePatient(patientUuid);
+  const [initialFormValues, setInitialFormValues] = useState<FormValues>({
+    patientUuid: v4(),
+    givenName: '',
+    middleName: '',
+    familyName: '',
+    unidentifiedPatient: false,
+    additionalGivenName: '',
+    additionalMiddleName: '',
+    additionalFamilyName: '',
+    addNameInLocalLanguage: false,
+    gender: '',
+    birthdate: null,
+    yearsEstimated: 0,
+    monthsEstimated: 0,
+    birthdateEstimated: false,
+    telephoneNumber: '',
+    address1: '',
+    address2: '',
+    cityVillage: '',
+    stateProvince: '',
+    country: '',
+    postalCode: '',
+    isDead: false,
+    deathDate: '',
+    deathCause: '',
+    relationships: [{ relatedPerson: '', relationship: '' }],
+    identifiers: [],
+  });
 
   useEffect(() => {
     (async () => {
-      if (patient) {
+      if (patientToEdit) {
         setInitialFormValues({
           ...initialFormValues,
-          ...getFormValuesFromFhirPatient(patient),
-          ...getAddressFieldValuesFromFhirPatient(patient),
-          ...getPhonePersonAttributeValueFromFhirPatient(patient),
-          identifiers: await getPatientIdentifiers(patientUuid),
+          ...getFormValuesFromFhirPatient(patientToEdit),
+          ...getAddressFieldValuesFromFhirPatient(patientToEdit),
+          ...getPhonePersonAttributeValueFromFhirPatient(patientToEdit),
         });
-      } else if (!isLoading && patientUuid) {
+      } else if (!isLoadingPatientToEdit && patientUuid) {
         const registration = await getPatientRegistration(patientUuid);
-        setInitialFormValues(registration?.formValues ?? fallback);
+
+        if (!registration._patientRegistrationData.formValues) {
+          console.error(
+            `Found a queued offline patient registration for patient ${patientUuid}, but without form values. Not using these values.`,
+          );
+          return;
+        }
+
+        setInitialFormValues(registration._patientRegistrationData.formValues);
       }
     })();
-  }, [isLoading, patient, patientUuid]);
+  }, [isLoadingPatientToEdit, patientToEdit, patientUuid]);
+
+  useEffect(() => {
+    if (patientUuid) {
+      getInitialPatientIdentifiers(patientUuid).then((identifiers) =>
+        setInitialFormValues((initialFormValues) => ({
+          ...initialFormValues,
+          identifiers,
+        })),
+      );
+    }
+  }, [patientUuid]);
 
   return [initialFormValues, setInitialFormValues];
 }
@@ -83,7 +93,7 @@ export function useInitialAddressFieldValues(patientUuid: string, fallback = {})
         });
       } else if (!isLoading && patientUuid) {
         const registration = await getPatientRegistration(patientUuid);
-        setInitialAddressFieldValues(registration?.initialAddressFieldValues ?? fallback);
+        setInitialAddressFieldValues(registration?._patientRegistrationData.initialAddressFieldValues ?? fallback);
       }
     })();
   }, [isLoading, patient, patientUuid]);
@@ -93,26 +103,25 @@ export function useInitialAddressFieldValues(patientUuid: string, fallback = {})
 
 export function usePatientUuidMap(
   patientUuid: string,
-  fallback = {},
+  fallback: PatientUuidMapType = {},
 ): [PatientUuidMapType, Dispatch<PatientUuidMapType>] {
-  const { isLoading, patient } = usePatient(patientUuid);
+  const { isLoading: isLoadingPatientToEdit, patient: patientToEdit } = usePatient(patientUuid);
   const [patientUuidMap, setPatientUuidMap] = useState(fallback);
 
   useEffect(() => {
-    (async () => {
-      if (patient) {
-        setPatientUuidMap({ ...patientUuidMap, ...getPatientUuidMapFromFhirPatient(patient) });
-      } else if (!isLoading && patientUuid) {
-        const registration = await getPatientRegistration(patientUuid);
-        setPatientUuidMap(registration?.initialAddressFieldValues ?? fallback);
-      }
-    })();
-  }, [isLoading, patient, patientUuid]);
+    if (patientToEdit) {
+      setPatientUuidMap({ ...patientUuidMap, ...getPatientUuidMapFromFhirPatient(patientToEdit) });
+    } else if (!isLoadingPatientToEdit && patientUuid) {
+      getPatientRegistration(patientUuid).then((registration) =>
+        setPatientUuidMap(registration?._patientRegistrationData.initialAddressFieldValues ?? fallback),
+      );
+    }
+  }, [isLoadingPatientToEdit, patientToEdit, patientUuid]);
 
   return [patientUuidMap, setPatientUuidMap];
 }
 
 async function getPatientRegistration(patientUuid: string) {
   const items = await getSynchronizationItems<PatientRegistration>(patientRegistration);
-  return items.find((item) => item.patientUuid === patientUuid);
+  return items.find((item) => item._patientRegistrationData.formValues.patientUuid === patientUuid);
 }