@kenyaemr/esm-patient-registration-app 4.3.0

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

@@ -0,0 +1,320 @@
+import { FetchResponse, getSynchronizationItems, openmrsFetch, useConfig, usePatient } from '@openmrs/esm-framework';
+import last from 'lodash-es/last';
+import camelCase from 'lodash-es/camelCase';
+import { Dispatch, useEffect, useMemo, useState } from 'react';
+import useSWR from 'swr';
+import { v4 } from 'uuid';
+import { RegistrationConfig } from '../config-schema';
+import { patientRegistration } from '../constants';
+import { useConceptAnswers, useGlobalProperties } from '../patient-verification/patient-verification-hook';
+import {
+  FormValues,
+  PatientRegistration,
+  PatientUuidMapType,
+  PersonAttributeResponse,
+  PatientIdentifierResponse,
+  ObsResponse,
+  ConceptAnswers,
+  Encounter,
+} from './patient-registration-types';
+import {
+  getAddressFieldValuesFromFhirPatient,
+  getFormValuesFromFhirPatient,
+  getPatientUuidMapFromFhirPatient,
+  getPhonePersonAttributeValueFromFhirPatient,
+  latestFirstEncounter,
+} from './patient-registration-utils';
+import { useInitialPatientRelationships } from './section/patient-relationships/relationships.resource';
+
+export function useInitialFormValues(patientUuid: string): [FormValues, Dispatch<FormValues>] {
+  const { martialStatus, education, occupation, educationLoad, loadingStatus } = useConcepts();
+  const { isLoading: isLoadingPatientToEdit, patient: patientToEdit } = usePatient(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 [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: '',
+    isDead: false,
+    deathDate: '',
+    deathCause: '',
+    relationships: [],
+    identifiers: {},
+    address: {},
+  });
+
+  useEffect(() => {
+    (async () => {
+      if (patientToEdit) {
+        setInitialFormValues({
+          ...initialFormValues,
+          ...getFormValuesFromFhirPatient(patientToEdit),
+          address: getAddressFieldValuesFromFhirPatient(patientToEdit),
+          ...getPhonePersonAttributeValueFromFhirPatient(patientToEdit),
+        });
+      } else if (!isLoadingPatientToEdit && patientUuid) {
+        const registration = await getPatientRegistration(patientUuid);
+
+        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);
+      }
+    })();
+  }, [isLoadingPatientToEdit, patientToEdit, patientUuid]);
+
+  // Setting authentication token
+
+  useEffect(() => {
+    if (!isLoadingToken && token) {
+      setInitialFormValues((initialFormValues) => ({ ...initialFormValues, token: String(token.access_token) }));
+    }
+  }, [isLoadingToken, token]);
+
+  // Set initial patient relationships
+  useEffect(() => {
+    if (!isLoadingRelationships && relationships) {
+      setInitialFormValues((initialFormValues) => ({
+        ...initialFormValues,
+        relationships,
+      }));
+    }
+  }, [isLoadingRelationships, relationships, setInitialFormValues]);
+
+  // Set Initial patient identifiers
+  useEffect(() => {
+    if (!isLoadingIdentifiers && identifiers) {
+      setInitialFormValues((initialFormValues) => ({
+        ...initialFormValues,
+        identifiers,
+      }));
+    }
+  }, [isLoadingIdentifiers, identifiers, setInitialFormValues]);
+
+  // 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;
+      });
+      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
+
+  useEffect(() => {
+    if (!educationLoad || !loadingStatus) {
+      setInitialFormValues((initialFormValues) => ({
+        ...initialFormValues,
+        concepts: [...occupation, ...martialStatus, ...education],
+      }));
+    }
+  }, [educationLoad, loadingStatus]);
+
+  return [initialFormValues, setInitialFormValues];
+}
+
+export function useInitialAddressFieldValues(patientUuid: string, fallback = {}): [object, Dispatch<object>] {
+  const { isLoading, patient } = usePatient(patientUuid);
+  const [initialAddressFieldValues, setInitialAddressFieldValues] = useState<object>(fallback);
+
+  useEffect(() => {
+    (async () => {
+      if (patient) {
+        setInitialAddressFieldValues({
+          ...initialAddressFieldValues,
+          address: getAddressFieldValuesFromFhirPatient(patient),
+        });
+      } else if (!isLoading && patientUuid) {
+        const registration = await getPatientRegistration(patientUuid);
+        setInitialAddressFieldValues(registration?._patientRegistrationData.initialAddressFieldValues ?? fallback);
+      }
+    })();
+  }, [isLoading, patient, patientUuid]);
+
+  return [initialAddressFieldValues, setInitialAddressFieldValues];
+}
+
+export function usePatientUuidMap(
+  patientUuid: string,
+  fallback: PatientUuidMapType = {},
+): [PatientUuidMapType, Dispatch<PatientUuidMapType>] {
+  const { isLoading: isLoadingPatientToEdit, patient: patientToEdit } = usePatient(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),
+      );
+    }
+  }, [isLoadingPatientToEdit, patientToEdit, patientUuid]);
+
+  return [patientUuidMap, setPatientUuidMap];
+}
+
+async function getPatientRegistration(patientUuid: string) {
+  const items = await getSynchronizationItems<PatientRegistration>(patientRegistration);
+  return items.find((item) => item._patientRegistrationData.formValues.patientUuid === patientUuid);
+}
+
+export function useInitialPatientIdentifiers(patientUuid: string): {
+  data: FormValues['identifiers'];
+  isLoading: boolean;
+} {
+  const shouldFetch = !!patientUuid;
+
+  const { data, error, isLoading } = useSWR<FetchResponse<{ results: Array<PatientIdentifierResponse> }>, Error>(
+    shouldFetch
+      ? `/ws/rest/v1/patient/${patientUuid}/identifier?v=custom:(uuid,identifier,identifierType:(uuid,required,name),preferred)`
+      : null,
+    openmrsFetch,
+  );
+
+  const result: {
+    data: FormValues['identifiers'];
+    isLoading: boolean;
+  } = useMemo(() => {
+    const identifiers: FormValues['identifiers'] = {};
+
+    data?.data?.results?.forEach((patientIdentifier) => {
+      identifiers[camelCase(patientIdentifier.identifierType.name)] = {
+        identifierUuid: patientIdentifier.uuid,
+        preferred: patientIdentifier.preferred,
+        initialValue: patientIdentifier.identifier,
+        identifierValue: patientIdentifier.identifier,
+        identifierTypeUuid: patientIdentifier.identifierType.uuid,
+        identifierName: patientIdentifier.identifierType.name,
+        required: patientIdentifier.identifierType.required,
+        selectedSource: null,
+        autoGeneration: false,
+      };
+    });
+    return {
+      data: identifiers,
+      isLoading,
+    };
+  }, [data, error]);
+
+  return result;
+}
+
+function useInitialEncounters(patientUuid: string, patientToEdit: fhir.Patient) {
+  const { registrationObs } = useConfig() as RegistrationConfig;
+  const { data, error, isLoading } = useSWR<FetchResponse<{ results: Array<Encounter> }>>(
+    patientToEdit
+      ? `/ws/rest/v1/encounter?patient=${patientUuid}&v=full&encounterType=${registrationObs.encounterTypeUuid}`
+      : null,
+    openmrsFetch,
+  );
+  const obs = data?.data.results.sort(latestFirstEncounter)?.at(0)?.obs;
+  const encounters = obs
+    ?.map(({ concept, value }) => ({ [concept['uuid']]: value['uuid'] }))
+    .reduce((accu, curr) => Object.assign(accu, curr), {});
+
+  return { data: encounters, isLoading, error };
+}
+
+function useInitialPersonAttributes(personUuid: string) {
+  const shouldFetch = !!personUuid;
+  const { data, error, isLoading } = useSWR<FetchResponse<{ results: Array<PersonAttributeResponse> }>, Error>(
+    shouldFetch
+      ? `/ws/rest/v1/person/${personUuid}/attribute?v=custom:(uuid,display,attributeType:(uuid,display,format),value)`
+      : null,
+    openmrsFetch,
+  );
+  const result = useMemo(() => {
+    return {
+      data: data?.data?.results,
+      isLoading,
+    };
+  }, [data, error]);
+  return result;
+}
+
+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 { data: martialStatus, isLoading: loadingStatus } = useConceptAnswers('1054AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA');
+  const { data: education, isLoading: educationLoad } = useConceptAnswers('1712AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA');
+  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',
+    },
+  ];
+
+  return { martialStatus, education, occupation, loadingStatus, educationLoad };
+}

package/src/patient-registration/patient-registration-types.tsx

@@ -0,0 +1,271 @@
+import { OpenmrsResource, Session } from '@openmrs/esm-framework';
+import { RegistrationConfig } from '../config-schema';
+import { SavePatientTransactionManager } from './form-manager';
+
+interface NameValue {
+  uuid: string;
+  preferred: boolean;
+  givenName: string;
+  middleName: string;
+  familyName: string;
+}
+
+export interface AttributeValue {
+  attributeType: string;
+  value: string;
+}
+
+/**
+ * Patient Identifier data as it is fetched and composed from the APIs.
+ */
+export interface FetchedPatientIdentifierType {
+  name: string;
+  required: boolean;
+  uuid: string;
+  fieldName: string;
+  format: string;
+  isPrimary: boolean;
+  /** See: https://github.com/openmrs/openmrs-core/blob/e3fb1ac0a052aeff0f957a150731757dd319693b/api/src/main/java/org/openmrs/PatientIdentifierType.java#L41 */
+  uniquenessBehavior: undefined | null | 'UNIQUE' | 'NON_UNIQUE' | 'LOCATION';
+}
+
+export interface PatientIdentifierValue {
+  identifierUuid?: string;
+  identifierTypeUuid: string;
+  initialValue: string;
+  identifierValue: string;
+  identifierName: string;
+  selectedSource: IdentifierSource;
+  autoGeneration?: boolean;
+  preferred: boolean;
+  required: boolean;
+}
+
+/**
+ * Extends the `FetchedPatientIdentifierType` with aggregated data.
+ */
+export interface PatientIdentifierType extends FetchedPatientIdentifierType {
+  identifierSources: Array<IdentifierSource>;
+  autoGenerationSource?: IdentifierSource;
+  checked?: boolean;
+  source?: IdentifierSource;
+}
+
+export interface IdentifierSource {
+  uuid: string;
+  name: string;
+  autoGenerationOption?: IdentifierSourceAutoGenerationOption;
+}
+
+export interface IdentifierSourceAutoGenerationOption {
+  manualEntryEnabled: boolean;
+  automaticGenerationEnabled: boolean;
+}
+
+export interface PatientIdentifier {
+  uuid?: string;
+  identifier: string;
+  identifierType?: string;
+  location?: string;
+  preferred?: boolean;
+}
+
+export interface PatientRegistration {
+  id?: number;
+  /**
+   * The preliminary patient in the FHIR format.
+   */
+  fhirPatient: fhir.Patient;
+  /**
+   * Internal data collected by patient-registration. Required for later syncing and editing.
+   * Not supposed to be used outside of this module.
+   */
+  _patientRegistrationData: {
+    isNewPatient: boolean;
+    formValues: FormValues;
+    patientUuidMap: PatientUuidMapType;
+    initialAddressFieldValues: Record<string, any>;
+    capturePhotoProps: CapturePhotoProps;
+    currentLocation: string;
+    initialIdentifierValues: FormValues['identifiers'];
+    currentUser: Session;
+    config: RegistrationConfig;
+    savePatientTransactionManager: SavePatientTransactionManager;
+  };
+}
+
+export type Relationship = {
+  relationshipType: string;
+  personA: string;
+  personB: string;
+};
+
+export type Patient = {
+  uuid: string;
+  identifiers: Array<PatientIdentifier>;
+  person: {
+    uuid: string;
+    names: Array<NameValue>;
+    gender: string;
+    birthdate: string;
+    birthdateEstimated: boolean;
+    attributes: Array<AttributeValue>;
+    addresses: Array<Record<string, string>>;
+    dead: boolean;
+    deathDate?: string;
+    causeOfDeath?: string;
+  };
+};
+
+export interface Encounter {
+  encounterDatetime: Date | string;
+  patient: string;
+  encounterType: string;
+  location: string;
+  encounterProviders: Array<{
+    provider: string;
+    encounterRole: string;
+  }>;
+  form: string;
+  obs: Array<{
+    concept: string;
+    value: string | number;
+  }>;
+}
+
+export interface RelationshipValue {
+  relatedPersonName?: string;
+  relatedPersonUuid: string;
+  relation?: string;
+  relationshipType: string;
+  /**
+   * Defines the action to be taken on the existing relationship
+   * @kind ADD -> adds a new relationship
+   * @kind UPDATE -> updates an existing relationship
+   * @kind DELETE -> deletes an existing relationship
+   * @kind undefined -> no operation on the existing relationship
+   */
+  action?: 'ADD' | 'UPDATE' | 'DELETE';
+  /**
+   * Value kept for restoring initial relationshipType value
+   */
+  initialrelationshipTypeValue?: string;
+  uuid?: string;
+}
+
+export interface FormValues {
+  patientUuid: string;
+  givenName: string;
+  middleName: string;
+  familyName: string;
+  unidentifiedPatient: boolean;
+  additionalGivenName: string;
+  additionalMiddleName: string;
+  additionalFamilyName: string;
+  addNameInLocalLanguage: boolean;
+  gender: string;
+  birthdate: Date | string;
+  yearsEstimated: number;
+  monthsEstimated: number;
+  birthdateEstimated: boolean;
+  telephoneNumber: string;
+  isDead: boolean;
+  deathDate: string;
+  deathCause: string;
+  relationships: Array<RelationshipValue>;
+  identifiers: {
+    [identifierFieldName: string]: PatientIdentifierValue;
+  };
+  attributes?: {
+    [attributeTypeUuid: string]: string;
+  };
+  obs?: {
+    [conceptUuid: string]: string;
+  };
+  address: {
+    [addressField: string]: string;
+  };
+  observation?: ObsResponse;
+  concepts?: Array<ConceptAnswers>;
+  token?: string;
+}
+
+export interface PatientUuidMapType {
+  additionalNameUuid?: string;
+  preferredNameUuid?: string;
+  preferredAddressUuid?: string;
+}
+
+export interface CapturePhotoProps {
+  imageData: string;
+  dateTime: string;
+}
+
+export interface AddressValidationSchemaType {
+  name: string;
+  label: string;
+  regex: RegExp;
+  regexFormat: string;
+}
+
+export interface CodedPersonAttributeConfig {
+  personAttributeUuid: string;
+  conceptUuid: string;
+}
+
+export interface TextBasedPersonAttributeConfig {
+  personAttributeUuid: string;
+  validationRegex: string;
+}
+export interface PatientIdentifierResponse {
+  uuid: string;
+  identifier: string;
+  preferred: boolean;
+  identifierType: {
+    uuid: string;
+    required: boolean;
+    name: string;
+  };
+}
+export interface PersonAttributeTypeResponse {
+  uuid: string;
+  display: string;
+  name: string;
+  description: string;
+  format: string;
+}
+
+export interface PersonAttributeResponse {
+  display: string;
+  uuid: string;
+  value:
+    | string
+    | {
+        uuid: string;
+        display: string;
+      };
+  attributeType: {
+    display: string;
+    uuid: string;
+    format: 'org.openmrs.Concept' | string;
+  };
+}
+
+export interface ConceptResponse {
+  uuid: string;
+  display: string;
+  datatype: {
+    uuid: string;
+    display: string;
+  };
+  answers: Array<ConceptAnswers>;
+  setMembers: Array<ConceptAnswers>;
+}
+
+export interface ConceptAnswers {
+  display: string;
+  uuid: string;
+}
+export interface ObsResponse {
+  results: Array<{ obs: Array<{ uuid: string; display: string; value: OpenmrsResource; concept: OpenmrsResource }> }>;
+}