(feat) O3-3367 Add support for person attributes

Author: CynthiaKamau

src/adapters/person-attributes-adapter.ts

@@ -0,0 +1,54 @@
+import { type PersonAttribute, type OpenmrsResource } from '@openmrs/esm-framework';
+import { type FormContextProps } from '../provider/form-provider';
+import { type FormField, type FormFieldValueAdapter, type FormProcessorContextProps } from '../types';
+import { clearSubmission } from '../utils/common-utils';
+import { isEmpty } from '../validators/form-validator';
+
+export const PersonAttributesAdapter: FormFieldValueAdapter = {
+  transformFieldValue: function (field: FormField, value: any, context: FormContextProps) {
+    clearSubmission(field);
+    if (field.meta?.previousValue?.value === value || isEmpty(value)) {
+      return null;
+    }
+    field.meta.submission.newValue = {
+      value: value,
+      attributeType: field.questionOptions?.attribute?.type,
+    };
+    return field.meta.submission.newValue;
+  },
+  getInitialValue: function (field: FormField, sourceObject: OpenmrsResource, context: FormProcessorContextProps) {
+    const rendering = field.questionOptions.rendering;
+
+    const personAttributeValue = context?.customDependencies.personAttributes.find(
+      (attribute: PersonAttribute) => attribute.attributeType.uuid === field.questionOptions.attribute?.type,
+    )?.value;
+    if (rendering === 'text') {
+      if (typeof personAttributeValue === 'string') {
+        return personAttributeValue;
+      } else if (
+        personAttributeValue &&
+        typeof personAttributeValue === 'object' &&
+        'display' in personAttributeValue
+      ) {
+        return personAttributeValue?.display;
+      }
+    } else if (rendering === 'ui-select-extended') {
+      if (personAttributeValue && typeof personAttributeValue === 'object' && 'uuid' in personAttributeValue) {
+        return personAttributeValue?.uuid;
+      }
+    }
+    return null;
+  },
+  getPreviousValue: function (field: FormField, sourceObject: OpenmrsResource, context: FormProcessorContextProps) {
+    return null;
+  },
+  getDisplayValue: function (field: FormField, value: any) {
+    if (value?.display) {
+      return value.display;
+    }
+    return value;
+  },
+  tearDown: function (): void {
+    return;
+  },
+};

src/api/index.ts

@@ -1,4 +1,4 @@
-import { fhirBaseUrl, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { fhirBaseUrl, openmrsFetch, type PersonAttribute, restBaseUrl } from '@openmrs/esm-framework';
 import { encounterRepresentation } from '../constants';
 import { type OpenmrsForm, type PatientIdentifier, type PatientProgramPayload } from '../types';
 import { isUuid } from '../utils/boolean-utils';
@@ -180,3 +180,36 @@ export function savePatientIdentifier(patientIdentifier: PatientIdentifier, pati
     body: JSON.stringify(patientIdentifier),
   });
 }
+
+export function savePersonAttribute(personAttribute: PersonAttribute, personUuid: string) {
+  let url: string;
+
+  if (personAttribute.uuid) {
+    url = `${restBaseUrl}/person/${personUuid}/attribute/${personAttribute.uuid}`;
+  } else {
+    url = `${restBaseUrl}/person/${personUuid}/attribute`;
+  }
+
+  return openmrsFetch(url, {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    method: 'POST',
+    body: JSON.stringify(personAttribute),
+  });
+}
+
+export async function getPersonAttributeTypeFormat(personAttributeTypeUuid: string) {
+  try {
+    const response = await openmrsFetch(
+      `${restBaseUrl}/personattributetype/${personAttributeTypeUuid}?v=custom:(format)`,
+    );
+    if (response) {
+      const { data } = response;
+      return data?.format;
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}

src/components/inputs/ui-select-extended/ui-select-extended.component.tsx

@@ -149,7 +149,7 @@ const UiSelectExtended: React.FC<FormFieldInputProps> = ({ field, errors, warnin
             selectedItem={selectedItem}
             placeholder={isSearchable ? t('search', 'Search') + '...' : null}
             shouldFilterItem={({ item, inputValue }) => {
-              if (!inputValue) {
+              if (!inputValue || items.find((item) => item.uuid == field.value)) {
                 // Carbon's initial call at component mount
                 return true;
               }

src/components/inputs/ui-select-extended/ui-select-extended.test.tsx

@@ -107,6 +107,14 @@ jest.mock('../../../registry/registry', () => {
   };
 });
 
+jest.mock('../../../hooks/usePersonAttributes', () => ({
+  usePersonAttributes: jest.fn().mockReturnValue({
+    personAttributes: [],
+    error: null,
+    isLoading: false,
+  }),
+}));
+
 const encounter = {
   uuid: 'encounter-uuid',
   obs: [

src/components/inputs/unspecified/unspecified.test.tsx

@@ -58,6 +58,14 @@ jest.mock('../../../hooks/useEncounter', () => ({
   }),
 }));
 
+jest.mock('../../../hooks/usePersonAttributes', () => ({
+  usePersonAttributes: jest.fn().mockReturnValue({
+    personAttributes: [],
+    error: null,
+    isLoading: false,
+  }),
+}));
+
 const renderForm = async (mode: SessionMode = 'enter') => {
   await act(async () => {
     render(

src/datasources/person-attribute-datasource.ts

@@ -0,0 +1,16 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { BaseOpenMRSDataSource } from './data-source';
+
+export class PersonAttributeLocationDataSource extends BaseOpenMRSDataSource {
+  constructor() {
+    super(null);
+  }
+
+  async fetchData(searchTerm: string, config?: Record<string, any>, uuid?: string): Promise<any[]> {
+    const rep = 'v=custom:(uuid,display)';
+    const url = `${restBaseUrl}/location?${rep}`;
+    const { data } = await openmrsFetch(searchTerm ? `${url}&q=${searchTerm}` : url);
+
+    return data?.results;
+  }
+}

src/datasources/select-concept-answers-datasource.ts

@@ -7,7 +7,7 @@ export class SelectConceptAnswersDatasource extends BaseOpenMRSDataSource {
   }
 
   fetchData(searchTerm: string, config?: Record<string, any>): Promise<any[]> {
-    const apiUrl = this.url.replace('conceptUuid', config.referencedValue || config.concept);
+    const apiUrl = this.url.replace('conceptUuid', config.concept || config.referencedValue);
     return openmrsFetch(apiUrl).then(({ data }) => {
       return data['setMembers'].length ? data['setMembers'] : data['answers'];
     });

src/form-engine.test.tsx

@@ -118,6 +118,14 @@ jest.mock('./hooks/useConcepts', () => ({
   }),
 }));
 
+jest.mock('./hooks/usePersonAttributes', () => ({
+  usePersonAttributes: jest.fn().mockReturnValue({
+    personAttributes: [],
+    error: null,
+    isLoading: false,
+  }),
+}));
+
 describe('Form engine component', () => {
   const user = userEvent.setup();
 

src/hooks/useFormJson.tsx

@@ -108,14 +108,17 @@ function validateFormsArgs(formUuid: string, rawFormJson: any): Error {
  * @param {string} [formSessionIntent] - The optional form session intent.
  * @returns {FormSchema} - The refined form JSON object of type FormSchema.
  */
-function refineFormJson(
+async function refineFormJson(
   formJson: any,
   schemaTransformers: FormSchemaTransformer[] = [],
   formSessionIntent?: string,
-): FormSchema {
+): Promise<FormSchema> {
   removeInlineSubForms(formJson, formSessionIntent);
   // apply form schema transformers
-  schemaTransformers.reduce((draftForm, transformer) => transformer.transform(draftForm), formJson);
+  for (let transformer of schemaTransformers) {
+    const draftForm = await transformer.transform(formJson);
+    formJson = draftForm;
+  }
   setEncounterType(formJson);
   return applyFormIntent(formSessionIntent, formJson);
 }
@@ -134,7 +137,7 @@ function parseFormJson(formJson: any): FormSchema {
  * @param {FormSchema} formJson - The input form JSON object of type FormSchema.
  * @param {string} formSessionIntent - The form session intent.
  */
-function removeInlineSubForms(formJson: FormSchema, formSessionIntent: string): void {
+async function removeInlineSubForms(formJson: FormSchema, formSessionIntent: string): Promise<void> {
   for (let i = formJson.pages.length - 1; i >= 0; i--) {
     const page = formJson.pages[i];
     if (
@@ -143,7 +146,7 @@ function removeInlineSubForms(formJson: FormSchema, formSessionIntent: string):
       page.subform?.form?.encounterType === formJson.encounterType
     ) {
       const nonSubformPages = page.subform.form.pages.filter((page) => !isTrue(page.isSubform));
-      formJson.pages.splice(i, 1, ...refineFormJson(page.subform.form, [], formSessionIntent).pages);
+      formJson.pages.splice(i, 1, ...(await refineFormJson(page.subform.form, [], formSessionIntent)).pages);
     }
   }
 }

src/hooks/usePersonAttributes.tsx

@@ -0,0 +1,30 @@
+import { openmrsFetch, type PersonAttribute, restBaseUrl } from '@openmrs/esm-framework';
+import { useEffect, useState } from 'react';
+
+export const usePersonAttributes = (patientUuid: string) => {
+  const [personAttributes, setPersonAttributes] = useState<Array<PersonAttribute>>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+
+  useEffect(() => {
+    if (patientUuid) {
+      openmrsFetch(`${restBaseUrl}/patient/${patientUuid}?v=custom:(attributes)`)
+        .then((response) => {
+          setPersonAttributes(response?.data?.attributes);
+          setIsLoading(false);
+        })
+        .catch((error) => {
+          setError(error);
+          setIsLoading(false);
+        });
+    } else {
+      setIsLoading(false);
+    }
+  }, [patientUuid]);
+
+  return {
+    personAttributes,
+    error,
+    isLoading: isLoading,
+  };
+};