@ampath/esm-patient-registration-app 6.0.1-pre.98 → 9.2.0-next.14

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

@@ -25,7 +25,10 @@ export const dummyFormValues: FormValues = {
   telephoneNumber: '0800001066',
   isDead: false,
   deathDate: '',
+  deathTime: '',
+  deathTimeFormat: 'AM',
   deathCause: '',
+  nonCodedCauseOfDeath: '',
   relationships: [],
   address: {
     address1: 'Bom Jesus Street',

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

@@ -3,18 +3,9 @@ import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { DummyDataInput, dummyFormValues } from './dummy-data-input.component';
 import { initialFormValues } from '../../patient-registration.component';
-import { type FormValues } from '../../patient-registration-types';
+import { type FormValues } from '../../patient-registration.types';
 
-jest.mock('@openmrs/esm-framework', () => {
-  const originalModule = jest.requireActual('@openmrs/esm-framework');
-
-  return {
-    ...originalModule,
-    validator: jest.fn(),
-  };
-});
-
-describe('dummy data input', () => {
+describe('Dummy data input', () => {
   let formValues: FormValues = initialFormValues;
 
   const setupInput = async () => {

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

@@ -1,6 +1,6 @@
-@use '@carbon/styles/scss/spacing';
-@use '@carbon/styles/scss/type';
-@import '../../patient-registration/patient-registration.scss';
+@use '@carbon/layout';
+@use '@carbon/type';
+@use '@openmrs/esm-styleguide/src/vars' as *;
 
 .fieldRow {
   display: flex;
@@ -10,7 +10,7 @@
 }
 
 .subFieldRow {
-  margin-bottom: 5px;
+  margin-bottom: 0.3125rem;
 }
 
 .label {
@@ -20,7 +20,7 @@
 
 .textID,
 .comboInput {
-  margin-bottom: spacing.$spacing-05;
+  margin-bottom: layout.$spacing-05;
 }
 
 .requiredField {
@@ -28,15 +28,15 @@
 }
 
 .input {
-  margin-right: 5px;
+  margin-right: 0.3125rem;
 }
 
 .checkboxField {
   display: flex;
   flex-direction: row;
   justify-content: flex-start;
-  width: 400px;
-  margin-left: 10px;
+  width: 25rem;
+  margin-left: 0.625rem;
 }
 
 .textInput {
@@ -50,9 +50,9 @@
 }
 
 .checkboxInput {
-  height: 1.5rem !important;
-  width: 1.5rem !important;
-  margin-top: 8px;
+  height: layout.$spacing-06 !important;
+  width: layout.$spacing-06 !important;
+  margin-top: layout.$spacing-03;
 }
 
 .selectInput {
@@ -89,7 +89,7 @@
 .IDInput {
   display: grid;
   grid-template-columns: 1fr auto;
-  align-items: end;
+  align-items: center;
 }
 
 .trashCan {
@@ -114,5 +114,9 @@
 
 .comboInputItemOption {
   margin: 0;
-  padding-left: 1rem;
+  padding-left: layout.$spacing-05;
+}
+
+.actionButtonContainer {
+  margin-left: layout.$spacing-05;
 }

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

@@ -1,24 +1,35 @@
-import { useConfig } from '@openmrs/esm-framework';
-import { createContext, type SetStateAction } from 'react';
+import { createContext, type SetStateAction, useContext } from 'react';
+import { type PatientIdentifierType, useConfig } from '@openmrs/esm-framework';
+import { type CapturePhotoProps, type FormValues } from './patient-registration.types';
 import { type RegistrationConfig } from '../config-schema';
-import { type FormValues, type CapturePhotoProps } from './patient-registration.types';
 
 export interface PatientRegistrationContextProps {
-  identifierTypes: Array<any>;
-  values: FormValues;
-  validationSchema: any;
-  inEditMode: boolean;
-  setFieldValue(field: string, value: any, shouldValidate?: boolean): void;
-  setCapturePhotoProps(value: SetStateAction<CapturePhotoProps>): void;
   currentPhoto: string;
-  isOffline: boolean;
+  identifierTypes: Array<PatientIdentifierType>;
+  inEditMode: boolean;
   initialFormValues: FormValues;
+  isOffline: boolean;
+  setCapturePhotoProps(value: SetStateAction<CapturePhotoProps>): void;
+  setFieldTouched(field: string, isTouched?: any, shouldValidate?: boolean): void;
+  setFieldValue(field: string, value: any, shouldValidate?: boolean): void;
   setInitialFormValues?: React.Dispatch<SetStateAction<FormValues>>;
+  validationSchema: any;
+  values: FormValues;
 }
 
 export const PatientRegistrationContext = createContext<PatientRegistrationContextProps | undefined>(undefined);
 
+export const PatientRegistrationContextProvider = PatientRegistrationContext.Provider;
+
+export const usePatientRegistrationContext = () => {
+  const context = useContext(PatientRegistrationContext);
+  if (!context) {
+    throw new Error('usePatientRegistrationContext must be used within a PatientRegistrationContextProvider');
+  }
+  return context;
+};
+
 export function useFieldConfig(field: string) {
-  const { fieldConfigurations } = useConfig() as RegistrationConfig;
+  const { fieldConfigurations } = useConfig<RegistrationConfig>();
   return fieldConfigurations[field];
 }

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

@@ -1,29 +1,26 @@
+import { type Dispatch, useEffect, useMemo, useState, useRef } from 'react';
+import { camelCase } from 'lodash-es';
+import { v4 } from 'uuid';
+import dayjs from 'dayjs';
+import useSWR from 'swr';
 import {
   type FetchResponse,
   type OpenmrsResource,
   getSynchronizationItems,
   openmrsFetch,
-  useConfig,
-  usePatient,
   restBaseUrl,
+  useConfig,
 } from '@openmrs/esm-framework';
-import last from 'lodash-es/last';
-import camelCase from 'lodash-es/camelCase';
-import { type Dispatch, useEffect, useMemo, useState } from 'react';
-import useSWR from 'swr';
-import { v4 } from 'uuid';
 import { type RegistrationConfig } from '../config-schema';
 import { patientRegistration } from '../constants';
-import { useConceptAnswers, useGlobalProperties } from '../patient-verification/patient-verification-hook';
+import { useInitialPatientRelationships } from './section/patient-relationships/relationships.resource';
 import {
+  type Encounter,
   type FormValues,
+  type PatientIdentifierResponse,
   type PatientRegistration,
   type PatientUuidMapType,
   type PersonAttributeResponse,
-  type PatientIdentifierResponse,
-  type Encounter,
-  type ConceptAnswers,
-  type ObsResponse,
 } from './patient-registration.types';
 import {
   getAddressFieldValuesFromFhirPatient,
@@ -32,38 +29,63 @@ import {
   getPhonePersonAttributeValueFromFhirPatient,
   latestFirstEncounter,
 } from './patient-registration-utils';
-import { useInitialPatientRelationships } from './section/patient-relationships/relationships.resource';
-import dayjs from 'dayjs';
 
-export function useInitialFormValues(patientUuid: string): [FormValues, Dispatch<FormValues>] {
-  const { martialStatus, education, occupation, educationLoad } = useConcepts();
-  const { isLoading: isLoadingPatientToEdit, patient: patientToEdit } = usePatient(patientUuid);
+interface AddressFieldValues {
+  address?: {
+    cityVillage?: string;
+    country?: string;
+    countyDistrict?: string;
+    postalCode?: string;
+    stateProvince?: string;
+    [key: string]: string | undefined;
+  };
+}
+
+interface DeathInfoResults {
+  causeOfDeath: OpenmrsResource | null;
+  causeOfDeathNonCoded: string | null;
+  dead: boolean;
+  deathDate: string;
+  display: string;
+  uuid: string;
+}
+
+export function useInitialFormValues(
+  isLoadingPatientToEdit: boolean,
+  patientToEdit: fhir.Patient,
+  patientUuid: string,
+): [FormValues, Dispatch<FormValues>] {
+  const { freeTextFieldConceptUuid } = useConfig<RegistrationConfig>();
+  const { data: deathInfo, isLoading: isLoadingDeathInfo } = useInitialPersonDeathInfo(patientUuid);
   const { data: attributes, isLoading: isLoadingAttributes } = useInitialPersonAttributes(patientUuid);
   const { data: identifiers, isLoading: isLoadingIdentifiers } = useInitialPatientIdentifiers(patientUuid);
   const { data: relationships, isLoading: isLoadingRelationships } = useInitialPatientRelationships(patientUuid);
-  const { data: obs, isLoading: isLoadingObs, obs: observations } = usePatientObs(patientUuid);
-  const { data: token, isLoading: isLoadingToken } = useGlobalProperties();
+  const { data: encounters } = useInitialEncounters(patientUuid, patientToEdit);
+
   const [initialFormValues, setInitialFormValues] = useState<FormValues>({
-    patientUuid: v4(),
-    givenName: '',
-    middleName: '',
-    familyName: '',
+    additionalFamilyName: '',
     additionalGivenName: '',
     additionalMiddleName: '',
-    additionalFamilyName: '',
     addNameInLocalLanguage: false,
-    gender: '',
+    address: {},
     birthdate: null,
-    yearsEstimated: 0,
-    monthsEstimated: 0,
     birthdateEstimated: false,
-    telephoneNumber: '',
-    isDead: false,
-    deathDate: '',
     deathCause: '',
-    relationships: [],
+    deathDate: undefined,
+    deathTime: undefined,
+    deathTimeFormat: 'AM',
+    familyName: '',
+    gender: '',
+    givenName: '',
     identifiers: {},
-    address: {},
+    isDead: false,
+    middleName: '',
+    monthsEstimated: 0,
+    nonCodedCauseOfDeath: '',
+    patientUuid: v4(),
+    relationships: [],
+    telephoneNumber: '',
+    yearsEstimated: 0,
   });
 
   useEffect(() => {
@@ -71,21 +93,20 @@ export function useInitialFormValues(patientUuid: string): [FormValues, Dispatch
       if (patientToEdit) {
         const birthdateEstimated = !/^\d{4}-\d{2}-\d{2}$/.test(patientToEdit.birthDate);
         const [years = 0, months = 0] = patientToEdit.birthDate.split('-').map((val) => parseInt(val));
-        // Please refer: https://github.com/openmrs/openmrs-esm-patient-management/pull/697#issuecomment-1562706118
         const estimatedMonthsAvailable = patientToEdit.birthDate.split('-').length > 1;
         const yearsEstimated = birthdateEstimated ? Math.floor(dayjs().diff(patientToEdit.birthDate, 'month') / 12) : 0;
         const monthsEstimated =
           birthdateEstimated && estimatedMonthsAvailable ? dayjs().diff(patientToEdit.birthDate, 'month') % 12 : 0;
 
-        setInitialFormValues({
-          ...initialFormValues,
+        setInitialFormValues((currentValues) => ({
+          ...currentValues,
           ...getFormValuesFromFhirPatient(patientToEdit),
           address: getAddressFieldValuesFromFhirPatient(patientToEdit),
           ...getPhonePersonAttributeValueFromFhirPatient(patientToEdit),
           birthdateEstimated: !/^\d{4}-\d{2}-\d{2}$/.test(patientToEdit.birthDate),
           yearsEstimated,
           monthsEstimated,
-        });
+        }));
       } else if (!isLoadingPatientToEdit && patientUuid) {
         const registration = await getPatientRegistration(patientUuid);
 
@@ -101,15 +122,26 @@ export function useInitialFormValues(patientUuid: string): [FormValues, Dispatch
     })();
   }, [isLoadingPatientToEdit, patientToEdit, patientUuid]);
 
-  // Setting authentication token
-
+  // Set initial patient death info
   useEffect(() => {
-    if (!isLoadingToken && token) {
-      setInitialFormValues((initialFormValues) => ({ ...initialFormValues, token: String(token.access_token) }));
+    if (!isLoadingDeathInfo && deathInfo?.dead) {
+      const deathDatetime = deathInfo.deathDate || null;
+      const deathDate = deathDatetime ? new Date(deathDatetime) : undefined;
+      const time = deathDate ? dayjs(deathDate).format('hh:mm') : undefined;
+      const timeFormat = deathDate ? (dayjs(deathDate).hour() >= 12 ? 'PM' : 'AM') : 'AM';
+      setInitialFormValues((initialFormValues) => ({
+        ...initialFormValues,
+        isDead: deathInfo.dead || false,
+        deathDate: deathDate,
+        deathTime: time,
+        deathTimeFormat: timeFormat,
+        deathCause: deathInfo.causeOfDeathNonCoded ? freeTextFieldConceptUuid : deathInfo.causeOfDeath?.uuid,
+        nonCodedCauseOfDeath: deathInfo.causeOfDeathNonCoded,
+      }));
     }
-  }, [isLoadingToken, token]);
+  }, [isLoadingDeathInfo, deathInfo, freeTextFieldConceptUuid]);
 
-  // Set initial patient relationships
+  // Combined effect for relationships and identifiers
   useEffect(() => {
     if (!isLoadingRelationships && relationships) {
       setInitialFormValues((initialFormValues) => ({
@@ -117,101 +149,118 @@ export function useInitialFormValues(patientUuid: string): [FormValues, Dispatch
         relationships,
       }));
     }
-  }, [isLoadingRelationships, relationships, setInitialFormValues]);
 
-  // Set Initial patient identifiers
-  useEffect(() => {
     if (!isLoadingIdentifiers && identifiers) {
       setInitialFormValues((initialFormValues) => ({
         ...initialFormValues,
         identifiers,
       }));
     }
-  }, [isLoadingIdentifiers, identifiers, setInitialFormValues]);
+  }, [isLoadingRelationships, relationships, isLoadingIdentifiers, identifiers]);
 
   // Set Initial person attributes
   useEffect(() => {
     if (!isLoadingAttributes && attributes) {
-      let personAttributes = {};
-      attributes.forEach((attribute) => {
-        personAttributes[attribute.attributeType.uuid] =
-          attribute.attributeType.format === 'org.openmrs.Concept' && typeof attribute.value === 'object'
-            ? attribute.value?.uuid
-            : attribute.value;
-      });
+      const personAttributes = attributes.reduce(
+        (acc, attribute) => ({
+          ...acc,
+          [attribute.attributeType.uuid]:
+            attribute.attributeType.format === 'org.openmrs.Concept' && typeof attribute.value === 'object'
+              ? attribute.value?.uuid
+              : attribute.value,
+        }),
+        {},
+      );
 
       setInitialFormValues((initialFormValues) => ({
         ...initialFormValues,
         attributes: personAttributes,
       }));
     }
-  }, [attributes, setInitialFormValues, isLoadingAttributes]);
-
-  // Set initial patient obs
-
-  useEffect(() => {
-    if (!isLoadingObs) {
-      setInitialFormValues((initialFormValues) => ({ ...initialFormValues, obs: obs, observation: observations }));
-    }
-  }, [isLoadingObs]);
-
-  // Set Initial encounter
+  }, [attributes, isLoadingAttributes]);
 
+  // Set Initial registration encounters
   useEffect(() => {
-    if (!educationLoad) {
+    if (patientToEdit && encounters) {
       setInitialFormValues((initialFormValues) => ({
         ...initialFormValues,
-        concepts: [...occupation, ...martialStatus, ...education],
+        obs: encounters as Record<string, string>,
       }));
     }
-  }, [educationLoad]);
+  }, [encounters, patientToEdit]);
 
   return [initialFormValues, setInitialFormValues];
 }
 
-export function useInitialAddressFieldValues(patientUuid: string, fallback = {}): [object, Dispatch<object>] {
-  const { isLoading, patient } = usePatient(patientUuid);
-  const [initialAddressFieldValues, setInitialAddressFieldValues] = useState<object>(fallback);
+export function useInitialAddressFieldValues(
+  fallback: AddressFieldValues = {},
+  isLoadingPatientToEdit: boolean,
+  patientToEdit: fhir.Patient,
+  patientUuid: string,
+): [AddressFieldValues, Dispatch<AddressFieldValues>] {
+  const fallbackRef = useRef(fallback);
+  const [initialAddressFieldValues, setInitialAddressFieldValues] = useState<AddressFieldValues>(fallbackRef.current);
 
   useEffect(() => {
     (async () => {
-      if (patient) {
-        setInitialAddressFieldValues({
-          ...initialAddressFieldValues,
-          address: getAddressFieldValuesFromFhirPatient(patient),
-        });
-      } else if (!isLoading && patientUuid) {
+      if (patientToEdit) {
+        setInitialAddressFieldValues((currentValues) => ({
+          ...currentValues,
+          address: getAddressFieldValuesFromFhirPatient(patientToEdit),
+        }));
+      } else if (!isLoadingPatientToEdit && patientUuid) {
         const registration = await getPatientRegistration(patientUuid);
-        setInitialAddressFieldValues(registration?._patientRegistrationData.initialAddressFieldValues ?? fallback);
+        setInitialAddressFieldValues(
+          registration?._patientRegistrationData.initialAddressFieldValues ?? fallbackRef.current,
+        );
       }
     })();
-  }, [isLoading, patient, patientUuid]);
+  }, [isLoadingPatientToEdit, patientToEdit, patientUuid]);
 
   return [initialAddressFieldValues, setInitialAddressFieldValues];
 }
 
 export function usePatientUuidMap(
-  patientUuid: string,
   fallback: PatientUuidMapType = {},
+  isLoadingPatientToEdit: boolean,
+  patientToEdit: fhir.Patient,
+  patientUuid: string,
 ): [PatientUuidMapType, Dispatch<PatientUuidMapType>] {
-  const { isLoading: isLoadingPatientToEdit, patient: patientToEdit } = usePatient(patientUuid);
+  const fallbackRef = useRef(fallback);
+  const [patientUuidMap, setPatientUuidMap] = useState(fallbackRef.current);
   const { data: attributes } = useInitialPersonAttributes(patientUuid);
-  const [patientUuidMap, setPatientUuidMap] = useState(fallback);
 
   useEffect(() => {
-    if (patientToEdit) {
-      setPatientUuidMap({ ...patientUuidMap, ...getPatientUuidMapFromFhirPatient(patientToEdit) });
-    } else if (!isLoadingPatientToEdit && patientUuid) {
-      getPatientRegistration(patientUuid).then((registration) =>
-        setPatientUuidMap(registration?._patientRegistrationData.initialAddressFieldValues ?? fallback),
-      );
+    const abortController = new AbortController();
+
+    async function updatePatientMap() {
+      if (patientToEdit) {
+        setPatientUuidMap((prevMap) => ({
+          ...prevMap,
+          ...getPatientUuidMapFromFhirPatient(patientToEdit),
+        }));
+      } else if (!isLoadingPatientToEdit && patientUuid) {
+        try {
+          const registration = await getPatientRegistration(patientUuid);
+          if (!abortController.signal.aborted) {
+            setPatientUuidMap(registration?._patientRegistrationData.initialAddressFieldValues ?? fallbackRef.current);
+          }
+        } catch (error) {
+          if (!abortController.signal.aborted) {
+            console.error('Failed to get patient registration:', error);
+          }
+        }
+      }
     }
+
+    updatePatientMap();
+    return () => abortController.abort();
   }, [isLoadingPatientToEdit, patientToEdit, patientUuid]);
 
   useEffect(() => {
     if (attributes) {
-      setPatientUuidMap((prevPatientUuidMap) => ({
-        ...prevPatientUuidMap,
+      setPatientUuidMap((prevMap) => ({
+        ...prevMap,
         ...getPatientAttributeUuidMapForPatient(attributes),
       }));
     }
@@ -261,13 +310,13 @@ export function useInitialPatientIdentifiers(patientUuid: string): {
       data: identifiers,
       isLoading,
     };
-  }, [data, error]);
+  }, [data?.data?.results, isLoading]);
 
   return result;
 }
 
 function useInitialEncounters(patientUuid: string, patientToEdit: fhir.Patient) {
-  const { registrationObs } = useConfig() as RegistrationConfig;
+  const { registrationObs } = useConfig<RegistrationConfig>();
   const { data, error, isLoading } = useSWR<FetchResponse<{ results: Array<Encounter> }>>(
     patientToEdit && registrationObs.encounterTypeUuid
       ? `${restBaseUrl}/encounter?patient=${patientUuid}&v=custom:(encounterDatetime,obs:(concept:ref,value:ref))&encounterType=${registrationObs.encounterTypeUuid}`
@@ -297,7 +346,24 @@ function useInitialPersonAttributes(personUuid: string) {
       data: data?.data?.results,
       isLoading,
     };
-  }, [data, error]);
+  }, [data?.data?.results, isLoading]);
+  return result;
+}
+
+function useInitialPersonDeathInfo(personUuid: string) {
+  const { data, error, isLoading } = useSWR<FetchResponse<DeathInfoResults>, Error>(
+    !!personUuid
+      ? `${restBaseUrl}/person/${personUuid}?v=custom:(uuid,display,causeOfDeath,dead,deathDate,causeOfDeathNonCoded)`
+      : null,
+    openmrsFetch,
+  );
+
+  const result = useMemo(() => {
+    return {
+      data: data?.data,
+      isLoading,
+    };
+  }, [data?.data, isLoading]);
   return result;
 }
 
@@ -308,104 +374,3 @@ function getPatientAttributeUuidMapForPatient(attributes: Array<PersonAttributeR
   });
   return attributeUuidMap;
 }
-
-export function usePatientObs(patientUuid: string) {
-  const {
-    registrationObs: { encounterTypeUuid },
-  } = useConfig() as RegistrationConfig;
-  const url = `/ws/rest/v1/encounter?patient=${patientUuid}&encounterType=${encounterTypeUuid}&v=custom:(obs:(uuid,display,concept:(uuid,display),value:(uuid,display)))`;
-  const { data, isLoading, error } = useSWR<{ data: ObsResponse }>(patientUuid ? url : null, openmrsFetch);
-  let obsObject = {};
-  const patientObs = last(data?.data?.results)?.obs?.forEach((ob) => {
-    Object.assign(obsObject, { [ob.concept.uuid]: ob.value.uuid });
-  });
-  return { data: obsObject, isLoading, error, obs: data?.data };
-}
-
-function useConcepts() {
-  const config = useConfig<RegistrationConfig>();
-  const { data: education, isLoading: educationLoad } = useConceptAnswers('a89e48ae-1350-11df-a1f1-0026b9348838');
-  const { data: occupation, isLoading: occupationLoad } = useConceptAnswers('a8a0a00e-1350-11df-a1f1-0026b9348838');
-  const { data: martialStatus, isLoading: martialStatusLoad } = useConceptAnswers(
-    'a899a9f2-1350-11df-a1f1-0026b9348838',
-  );
-
-  /* const occupation: Array<ConceptAnswers> = [
-    {
-      uuid: '1538AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
-      display: 'Farmer',
-    },
-    {
-      uuid: '1540AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
-      display: 'Employee',
-    },
-    {
-      uuid: '1539AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
-      display: 'Trader',
-    },
-    {
-      uuid: '159465AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
-      display: 'Student',
-    },
-    {
-      uuid: '159466AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
-      display: 'Driver',
-    },
-    {
-      uuid: '1107AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
-      display: 'None',
-    },
-    {
-      uuid: '5622AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
-      display: 'Other',
-    },
-  ]; */
-  /* const martialStatus: Array<ConceptAnswers> = [
-    {
-      uuid: 'a8b03712-1350-11df-a1f1-0026b9348838',
-      display: 'Married polygamous',
-    },
-    {
-      uuid: 'a8aa76b0-1350-11df-a1f1-0026b9348838',
-      display: 'Married monogamous',
-    },
-    {
-      uuid: 'a899ad58-1350-11df-a1f1-0026b9348838',
-      display: 'Divorced',
-    },
-    {
-      uuid: 'a899ae34-1350-11df-a1f1-0026b9348838',
-      display: 'Widowed',
-    },
-    {
-      uuid: 'a899af10-1350-11df-a1f1-0026b9348838',
-      display: 'Cohabiting',
-    },
-    {
-      uuid: 'a899ac7c-1350-11df-a1f1-0026b9348838',
-      display: 'Single',
-    },
-    {
-      uuid: 'a899aba0-1350-11df-a1f1-0026b9348838',
-      display: 'Separated',
-    },
-    {
-      uuid: '7831f002-331d-4f07-bf91-6bb65cd31050',
-      display: 'Sexual Partner/Sexual Partner',
-    },
-    {
-      uuid: 'a89ad3a4-1350-11df-a1f1-0026b9348838',
-      display: 'Not Applicable',
-    },
-    {
-      uuid: 'a8aaf3e2-1350-11df-a1f1-0026b9348838',
-      display: 'Other Non-Coded',
-    },
-  ];
-  */
-  //const martialStatus: Array<ConceptAnswers> = config.fieldDefinitions
-  //  .find((fieldDefinition) => fieldDefinition.id === 'maritalStatus')
-  //  .customConceptAnswers.map((concept) => ({ uuid: concept.uuid, display: concept.label }));
-
-  return { martialStatus, education, occupation, educationLoad, occupationLoad };
-}

package/src/patient-registration/patient-registration-utils.test.ts

@@ -0,0 +1,33 @@
+import { filterOutUndefinedPatientIdentifiers } from './patient-registration-utils';
+
+describe('filterOutUndefinedPatientIdentifiers', () => {
+  const getIdentifiers = (autoGeneration = true, manualEntryEnabled = false) => ({
+    OpenMRSId: {
+      autoGeneration: autoGeneration,
+      identifierName: 'OpenMRS ID',
+      identifierTypeUuid: '05a29f94-c0ed-11e2-94be-8c13b969e334',
+      identifierValue: undefined,
+      initialValue: '100GEJ',
+      preferred: true,
+      required: true,
+      selectedSource: {
+        uuid: '01af8526-cea4-4175-aa90-340acb411771',
+        name: 'Generator for OpenMRS ID',
+        autoGenerationOption: {
+          manualEntryEnabled: manualEntryEnabled,
+          automaticGenerationEnabled: autoGeneration,
+        },
+      },
+    },
+  });
+
+  it('should fitler out undefined identifiers', () => {
+    const filteredIdentifiers = filterOutUndefinedPatientIdentifiers(getIdentifiers());
+    expect(filteredIdentifiers.OpenMRSId).not.toBeDefined();
+  });
+
+  it('should retain auto-generated identifiers with manual entry', () => {
+    const filteredIdentifiers = filterOutUndefinedPatientIdentifiers(getIdentifiers(true, true));
+    expect(filteredIdentifiers.OpenMRSId).toBeDefined();
+  });
+});