@kenyaemr/esm-patient-registration-app 8.0.1-pre.99 → 8.0.2

package/src/patient-registration/field/id/id-field.test.tsx

@@ -1,18 +1,19 @@
 import React from 'react';
-import userEvent from '@testing-library/user-event';
-import { render, screen } from '@testing-library/react';
 import { Form, Formik } from 'formik';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
 import { getDefaultsFromConfigSchema, useConfig } from '@openmrs/esm-framework';
-import { Identifiers } from './id-field.component';
-import { mockOpenmrsId, mockIdentifierTypes, mockPatient, mockSession } from '__mocks__';
-import { type RegistrationConfig, esmPatientRegistrationSchema } from '../../../config-schema';
-import { type Resources, ResourcesContext } from '../../../offline.resources';
+import { type AddressTemplate, type IdentifierSource } from '../../patient-registration.types';
+import { mockIdentifierTypes, mockOpenmrsId, mockPatient, mockSession } from '__mocks__';
+import { esmPatientRegistrationSchema, type RegistrationConfig } from '../../../config-schema';
+import { ResourcesContext, type Resources } from '../../../offline.resources';
 import { PatientRegistrationContext, type PatientRegistrationContextProps } from '../../patient-registration-context';
+import { Identifiers, setIdentifierSource } from './id-field.component';
 
 const mockUseConfig = jest.mocked(useConfig<RegistrationConfig>);
 
 const mockResourcesContextValue = {
-  addressTemplate: null,
+  addressTemplate: null as unknown as AddressTemplate,
   currentSession: mockSession.data,
   identifierTypes: [],
   relationshipTypes: [],
@@ -52,7 +53,7 @@ const mockContextValues: PatientRegistrationContextProps = {
   setInitialFormValues: jest.fn(),
   validationSchema: null,
   values: mockInitialFormValues,
-};
+} as unknown as PatientRegistrationContextProps;
 
 describe('Identifiers', () => {
   beforeEach(() => {
@@ -120,3 +121,21 @@ describe('Identifiers', () => {
     expect(screen.getByRole('button', { name: 'Close overlay' })).toBeInTheDocument();
   });
 });
+
+describe('setIdentifierSource', () => {
+  describe('auto-generation', () => {
+    it('should return auto-generated as the identifier value', () => {
+      const identifierSource = { autoGenerationOption: { automaticGenerationEnabled: true } } as IdentifierSource;
+      const { identifierValue } = setIdentifierSource(identifierSource, '', '');
+      expect(identifierValue).toBe('auto-generated');
+    });
+
+    it('should return the identifier value when manual entry enabled', () => {
+      const identifierSource = {
+        autoGenerationOption: { automaticGenerationEnabled: true, manualEntryEnabled: true },
+      } as IdentifierSource;
+      const { identifierValue } = setIdentifierSource(identifierSource, '10001V', '');
+      expect(identifierValue).toBe('10001V');
+    });
+  });
+});

package/src/patient-registration/field/name/name-field.component.tsx

@@ -21,7 +21,7 @@ function checkNumber(value: string) {
 
 export const NameField = () => {
   const { t } = useTranslation();
-  const { setCapturePhotoProps, currentPhoto, setFieldValue } = useContext(PatientRegistrationContext);
+  const { setCapturePhotoProps, currentPhoto, setFieldValue, setFieldTouched } = useContext(PatientRegistrationContext);
   const {
     fieldConfigurations: {
       name: {
@@ -48,6 +48,7 @@ export const NameField = () => {
           imageData: dataUri,
           dateTime: photoDateTime,
         });
+        setFieldTouched('photo', true, false);
       }
     },
     [setCapturePhotoProps],
@@ -63,6 +64,9 @@ export const NameField = () => {
       setFieldValue('familyName', defaultUnknownFamilyName);
       setUnknownPatient('true');
     }
+    setFieldTouched('givenName', true);
+    setFieldTouched('familyName', true);
+    setFieldTouched(`attributes.${unidentifiedPatientAttributeTypeUuid}`, true, false);
   };
 
   const firstNameField = (

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

@@ -98,6 +98,7 @@ export function CodedPersonAttributeField({
               return (
                 <>
                   <Select
+                    style={{ marginBottom: '1rem' }}
                     id={id}
                     name={`person-attribute-${personAttributeType.uuid}`}
                     labelText={label ?? personAttributeType?.display}

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

@@ -1,19 +1,43 @@
-import React from 'react';
-import { Field } from 'formik';
+import React, { useContext, useEffect } from 'react';
+import { Field, type FieldProps } from 'formik';
 import { Layer, Select, SelectItem } from '@carbon/react';
-import { type PersonAttributeTypeResponse } from '../../patient-registration.types';
 import { useTranslation } from 'react-i18next';
-import styles from './../field.scss';
 import classNames from 'classnames';
+import { PatientRegistrationContext } from '../../patient-registration-context';
+import styles from './../field.scss';
+import { ResourcesContext } from '../../../offline.resources';
+import useUpdateIdentifierRequirement from './useUpdateIdentifierRequirement';
 
-type CustomPersonAttributeFieldProps = {
+interface PersonAttributeTypeResponse {
+  uuid: string;
+  display?: string;
+}
+
+interface ConceptAnswer {
+  uuid?: string;
+  name?: string;
+  label?: string;
+  showServiceExpression?: {
+    attributeTypeUuid: string;
+    value: string;
+  };
+}
+
+interface CustomPersonAttributeFieldProps {
   id: string;
   personAttributeType: PersonAttributeTypeResponse;
   answerConceptSetUuid: string;
   label?: string;
-  customConceptAnswers: Array<{ uuid: string; label?: string }>;
+  customConceptAnswers: ConceptAnswer[];
   required: boolean;
-};
+}
+
+interface PatientRegistrationContextType {
+  setFieldValue: (field: string, value: any) => void;
+  values: {
+    attributes?: Record<string, string>;
+  };
+}
 
 const CustomPersonAttributeField: React.FC<CustomPersonAttributeFieldProps> = ({
   personAttributeType,
@@ -24,30 +48,55 @@ const CustomPersonAttributeField: React.FC<CustomPersonAttributeFieldProps> = ({
 }) => {
   const { t } = useTranslation();
   const fieldName = `attributes.${personAttributeType.uuid}`;
+  const { setFieldValue, values } = useContext(PatientRegistrationContext);
+  useUpdateIdentifierRequirement(setFieldValue, values);
+  // TODO: Improve this logic
+  const filteredCustomConceptAnswers = customConceptAnswers.filter((answer) => {
+    const showExpression = answer.showServiceExpression;
+    if (!showExpression) return true;
+
+    const attributeValue = values?.attributes?.[showExpression.attributeTypeUuid];
+    const answerCadreId = answer.name;
+
+    if (answerCadreId == null) return true;
+
+    return showExpression.value.toLowerCase() === attributeValue?.toLowerCase();
+  });
+
+  useEffect(() => {
+    return () => {
+      setFieldValue(fieldName, '');
+    };
+  }, [fieldName, setFieldValue]);
+
+  const renderSelect = ({ field, form: { touched, errors } }: FieldProps) => {
+    const hasError = errors[fieldName] && touched[fieldName];
+    const displayLabel = label ?? personAttributeType?.display ?? '';
+
+    return (
+      <Select
+        id={id}
+        name={`person-attribute-${personAttributeType.uuid}`}
+        labelText={displayLabel}
+        invalid={Boolean(hasError)}
+        required={required}
+        {...field}>
+        <SelectItem value="" text={t('selectAnOption', 'Select an option')} />
+        {filteredCustomConceptAnswers.map((answer) => (
+          <SelectItem
+            key={answer.uuid ?? answer.name}
+            value={answer.uuid ?? answer.name ?? ''}
+            text={answer.label ?? answer.uuid ?? answer.name ?? ''}
+          />
+        ))}
+      </Select>
+    );
+  };
 
   return (
     <div className={classNames(styles.customField, styles.halfWidthInDesktopView)}>
       <Layer>
-        <Field name={fieldName}>
-          {({ field, form: { touched, errors }, meta }) => {
-            return (
-              <>
-                <Select
-                  id={id}
-                  name={`person-attribute-${personAttributeType.uuid}`}
-                  labelText={label ?? personAttributeType?.display}
-                  invalid={errors[fieldName] && touched[fieldName]}
-                  required={required}
-                  {...field}>
-                  <SelectItem value={''} text={t('selectAnOption', 'Select an option')} />
-                  {customConceptAnswers.map((answer) => (
-                    <SelectItem key={answer.uuid} value={answer.uuid} text={answer.uuid} />
-                  ))}
-                </Select>
-              </>
-            );
-          }}
-        </Field>
+        <Field name={fieldName}>{renderSelect}</Field>
       </Layer>
     </div>
   );

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

@@ -0,0 +1,105 @@
+import React, { useCallback, useMemo, useRef, useState } from 'react';
+import classNames from 'classnames';
+import { Field, useField } from 'formik';
+import { type PersonAttributeTypeResponse } from '../../patient-registration.types';
+import styles from './../field.scss';
+import { useLocations } from './location-person-attribute-field.resource';
+import { ComboBox, InlineLoading, Layer } from '@carbon/react';
+import { useTranslation } from 'react-i18next';
+
+export interface LocationPersonAttributeFieldProps {
+  id: string;
+  personAttributeType: PersonAttributeTypeResponse;
+  label?: string;
+  locationTag: string;
+  required?: boolean;
+}
+
+export function LocationPersonAttributeField({
+  personAttributeType,
+  id,
+  label,
+  locationTag,
+  required,
+}: LocationPersonAttributeFieldProps) {
+  const { t } = useTranslation();
+  const fieldName = `attributes.${personAttributeType.uuid}`;
+  const [field, meta, { setValue }] = useField(`attributes.${personAttributeType.uuid}`);
+  const [searchQuery, setSearchQuery] = useState<string>('');
+  const { locations, isLoading, loadingNewData } = useLocations(locationTag || null, searchQuery);
+  const prevLocationOptions = useRef([]);
+
+  const locationOptions = useMemo(() => {
+    if (!(isLoading && loadingNewData)) {
+      const newOptions = locations.map(({ resource: { id, name } }) => ({ value: id, label: name }));
+      prevLocationOptions.current = newOptions;
+      return newOptions;
+    }
+    return prevLocationOptions.current;
+  }, [locations, isLoading, loadingNewData]);
+
+  const selectedItem = useMemo(() => {
+    if (typeof meta.value === 'string') {
+      return locationOptions.find(({ value }) => value === meta.value) || null;
+    }
+    if (typeof meta.value === 'object' && meta.value) {
+      return locationOptions.find(({ value }) => value === meta.value.uuid) || null;
+    }
+    return null;
+  }, [locationOptions, meta.value]);
+
+  // Callback for when updating the combobox input
+  const handleInputChange = useCallback(
+    (value: string | null) => {
+      if (value) {
+        // If the value exists in the locationOptions (i.e. a label matches the input), exit the function
+        if (locationOptions.find(({ label }) => label === value)) return;
+        // If the input is a new value, set the search query
+        setSearchQuery(value);
+        // Clear the current selected value since the input doesn't match any existing options
+        setValue(null);
+      }
+    },
+    [locationOptions, setValue],
+  );
+  const handleSelect = useCallback(
+    ({ selectedItem }) => {
+      if (selectedItem) {
+        setValue(selectedItem.value);
+      }
+    },
+    [setValue],
+  );
+
+  return (
+    <div
+      className={classNames(styles.customField, styles.halfWidthInDesktopView, styles.locationAttributeFieldContainer)}>
+      <Layer>
+        <Field name={fieldName}>
+          {({ field, form: { touched, errors } }) => {
+            return (
+              <ComboBox
+                id={id}
+                name={`person-attribute-${personAttributeType.uuid}`}
+                titleText={label}
+                items={locationOptions}
+                placeholder={t('searchLocationPersonAttribute', 'Search location')}
+                onInputChange={handleInputChange}
+                required={required}
+                onChange={handleSelect}
+                selectedItem={selectedItem}
+                invalid={errors[fieldName] && touched[fieldName]}
+                typeahead
+              />
+            );
+          }}
+        </Field>
+      </Layer>
+      {loadingNewData && (
+        <div className={styles.loadingContainer}>
+          <InlineLoading />
+        </div>
+      )}
+    </div>
+  );
+}

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

@@ -0,0 +1,48 @@
+import { useMemo } from 'react';
+import { type FetchResponse, fhirBaseUrl, openmrsFetch, useDebounce } from '@openmrs/esm-framework';
+import { type LocationEntry, type LocationResponse } from '@kenyaemr/esm-service-queues-app/src/types';
+import useSWR from 'swr';
+
+interface UseLocationsResult {
+  locations: Array<LocationEntry>;
+  isLoading: boolean;
+  loadingNewData: boolean;
+}
+
+export function useLocations(locationTag: string | null, searchQuery: string = ''): UseLocationsResult {
+  const debouncedSearchQuery = useDebounce(searchQuery);
+
+  const constructUrl = useMemo(() => {
+    let url = `${fhirBaseUrl}/Location?`;
+    let urlSearchParameters = new URLSearchParams();
+    urlSearchParameters.append('_summary', 'data');
+
+    if (!debouncedSearchQuery) {
+      urlSearchParameters.append('_count', '10');
+    }
+
+    if (locationTag) {
+      urlSearchParameters.append('_tag', locationTag);
+    }
+
+    if (typeof debouncedSearchQuery === 'string' && debouncedSearchQuery != '') {
+      urlSearchParameters.append('name:contains', debouncedSearchQuery);
+    }
+
+    return url + urlSearchParameters.toString();
+  }, [locationTag, debouncedSearchQuery]);
+
+  const { data, error, isLoading, isValidating } = useSWR<FetchResponse<LocationResponse>, Error>(
+    constructUrl,
+    openmrsFetch,
+  );
+
+  return useMemo(
+    () => ({
+      locations: data?.data?.entry || [],
+      isLoading,
+      loadingNewData: isValidating,
+    }),
+    [data, isLoading, isValidating],
+  );
+}

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

@@ -1,11 +1,12 @@
 import React, { useMemo } from 'react';
-import { InlineNotification, TextInputSkeleton, SkeletonText } from '@carbon/react';
+import { InlineNotification, TextInputSkeleton } from '@carbon/react';
 import { type FieldDefinition } from '../../../config-schema';
 import { CodedPersonAttributeField } from './coded-person-attribute-field.component';
 import { usePersonAttributeType } from './person-attributes.resource';
 import { TextPersonAttributeField } from './text-person-attribute-field.component';
 import { useTranslation } from 'react-i18next';
 import styles from '../field.scss';
+import { LocationPersonAttributeField } from './location-person-attribute-field.component';
 import CustomPersonAttributeField from './custom-person-attribute-field.component';
 
 export interface PersonAttributeFieldProps {
@@ -55,6 +56,16 @@ export function PersonAttributeField({ fieldDefinition }: PersonAttributeFieldPr
             required={fieldDefinition.validation?.required ?? false}
           />
         );
+      case 'org.openmrs.Location':
+        return (
+          <LocationPersonAttributeField
+            personAttributeType={personAttributeType}
+            locationTag={fieldDefinition.locationTag}
+            label={fieldDefinition.label}
+            id={fieldDefinition?.id}
+            required={fieldDefinition.validation?.required ?? false}
+          />
+        );
       default:
         return (
           <InlineNotification kind="error" title="Error">

package/src/patient-registration/field/person-attributes/useUpdateIdentifierRequirement.tsx

@@ -0,0 +1,83 @@
+import { useEffect, useCallback, useRef, useMemo, useContext } from 'react';
+import { deleteIdentifierType, initializeIdentifier } from '../id/id-field.component';
+import { ResourcesContext } from '../../../offline.resources';
+
+const useUpdateIdentifierRequirement = (setFieldValue, values) => {
+  const { identifierTypes = [] } = useContext(ResourcesContext);
+  const previousAttributes = useRef(values.attributes);
+  const previousIdentifiers = useRef(values.identifiers);
+
+  const publicationNumberIdentifier = useMemo(
+    () => identifierTypes?.find((identifier) => identifier.name === 'Publication Number'),
+    [identifierTypes],
+  );
+
+  // Memoize the civilian check
+  const isCivilian = useMemo(() => Object.values(values.attributes ?? {}).includes('Civilian'), [values.attributes]);
+
+  // Memoize the identifier initialization logic
+  const initializePublicationIdentifier = useCallback(
+    (currentIdentifiers) => {
+      if (!publicationNumberIdentifier) {
+        console.warn('Publication Number identifier type not found');
+        return null;
+      }
+
+      const initializedIdentifier = initializeIdentifier(
+        publicationNumberIdentifier,
+        currentIdentifiers[publicationNumberIdentifier.uuid],
+      );
+
+      return initializedIdentifier;
+    },
+    [publicationNumberIdentifier],
+  );
+  // Only run the effect if isCivilian is true
+  useEffect(() => {
+    // Skip if we don't have the required data
+    if (!values.attributes || !publicationNumberIdentifier) {
+      return;
+    }
+
+    // Check if relevant values have actually changed
+    const attributesChanged = previousAttributes.current !== values.attributes;
+    const identifiersChanged = previousIdentifiers.current !== values.identifiers;
+
+    if (!attributesChanged && !identifiersChanged) {
+      return;
+    }
+
+    // Update refs
+    previousAttributes.current = values.attributes;
+    previousIdentifiers.current = values.identifiers;
+    const isDependant = Object.values(values.attributes ?? {}).includes('Dependant');
+    // Only proceed if the user is a civilian
+    if (isCivilian && isDependant) {
+      const initializedIdentifier = initializePublicationIdentifier(values.identifiers);
+
+      // check if values.identifiers already has the publication number identifier
+      const hasPublicationNumberIdentifier = values.identifiers[publicationNumberIdentifier.fieldName];
+
+      if (initializedIdentifier && !hasPublicationNumberIdentifier) {
+        setFieldValue('identifiers', {
+          ...values.identifiers,
+          [publicationNumberIdentifier.fieldName]: { ...initializedIdentifier, required: true },
+        });
+      }
+    } else {
+      // Before deleting the publication number identifier, check if it exists
+      if (values.identifiers[publicationNumberIdentifier.fieldName]) {
+        setFieldValue('identifiers', deleteIdentifierType(values.identifiers, publicationNumberIdentifier.fieldName));
+      }
+    }
+  }, [
+    values.attributes,
+    values.identifiers,
+    isCivilian,
+    publicationNumberIdentifier,
+    initializePublicationIdentifier,
+    setFieldValue,
+  ]);
+};
+
+export default useUpdateIdentifierRequirement;

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

@@ -1,8 +1,11 @@
 import { FormManager } from './form-manager';
 import { type FormValues } from './patient-registration.types';
+import { generateIdentifier } from './patient-registration.resource';
 
 jest.mock('./patient-registration.resource');
 
+const mockGenerateIdentifier = generateIdentifier as jest.Mock;
+
 const formValues: FormValues = {
   patientUuid: '',
   givenName: '',
@@ -20,7 +23,10 @@ const formValues: FormValues = {
   telephoneNumber: '',
   isDead: false,
   deathDate: 'string',
+  deathTime: '',
+  deathTimeFormat: 'AM',
   deathCause: 'string',
+  nonCodedCauseOfDeath: '',
   relationships: [],
   address: {
     address1: '',
@@ -63,5 +69,20 @@ describe('FormManager', () => {
         },
       ]);
     });
+
+    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,23 +1,24 @@
 import {
   type FetchResponse,
-  type Session,
-  type StyleguideConfigObject,
   getConfig,
   openmrsFetch,
   queueSynchronizationItem,
   restBaseUrl,
+  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,
@@ -25,14 +26,16 @@ import {
   deletePersonName,
   deleteRelationship,
   generateIdentifier,
+  getDatetime,
+  saveEncounter,
   savePatient,
   savePatientPhoto,
   saveRelationship,
-  updateRelationship,
   updatePatientIdentifier,
-  saveEncounter,
+  updateRelationship,
 } from './patient-registration.resource';
 import { type RegistrationConfig } from '../config-schema';
+import dayjs from 'dayjs';
 
 export type SavePatientForm = (
   isNewPatient: boolean,
@@ -62,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,
@@ -115,6 +118,7 @@ export class FormManager {
       patientUuidMap,
       initialAddressFieldValues,
       patientIdentifiers,
+      config,
     );
 
     FormManager.getDeletedNames(values.patientUuid, patientUuidMap).forEach(async (name) => {
@@ -236,11 +240,16 @@ export class FormManager {
           initialValue,
         } = patientIdentifier;
 
-        const identifier = !autoGeneration
-          ? identifierValue
-          : await (
-              await generateIdentifier(selectedSource.uuid)
-            ).data.identifier;
+        const autoGenerationManualEntry =
+          autoGeneration && selectedSource?.autoGenerationOption?.manualEntryEnabled && !!identifierValue;
+
+        const identifier =
+          !autoGeneration || autoGenerationManualEntry
+            ? identifierValue
+            : await (
+                await generateIdentifier(selectedSource.uuid)
+              ).data.identifier;
+
         const identifierToCreate = {
           uuid: identifierUuid,
           identifier,
@@ -296,6 +305,7 @@ export class FormManager {
     patientUuidMap: PatientUuidMapType,
     initialAddressFieldValues: Record<string, any>,
     identifiers: Array<PatientIdentifier>,
+    config?: RegistrationConfig,
   ): Patient {
     let birthdate;
     if (values.birthdate instanceof Date) {
@@ -316,7 +326,7 @@ export class FormManager {
         birthdateEstimated: values.birthdateEstimated,
         attributes: FormManager.getPatientAttributes(isNewPatient, values, patientUuidMap),
         addresses: [values.address],
-        ...FormManager.getPatientDeathInfo(values),
+        ...FormManager.getPatientDeathInfo(values, config),
       },
       identifiers,
     };
@@ -375,12 +385,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 }),
     };
   }