@olaboot/esm-form-engine-lib 4.1.0

package/src/hooks/useInitialValues.ts

@@ -0,0 +1,39 @@
+import { useEffect, useState } from 'react';
+import { type FormProcessorContextProps } from '../types';
+import { type FormProcessor } from '../processors/form-processor';
+
+const useInitialValues = (
+  formProcessor: FormProcessor,
+  isLoadingContextDependencies: boolean,
+  context: FormProcessorContextProps,
+) => {
+  const [isLoadingInitialValues, setIsLoadingInitialValues] = useState(true);
+  const [initialValues, setInitialValues] = useState({});
+  const [error, setError] = useState(null);
+
+  useEffect(() => {
+    if (
+      formProcessor &&
+      !isLoadingContextDependencies &&
+      context.formFields?.length &&
+      Object.keys(context.formFieldAdapters).length &&
+      !Object.keys(initialValues).length
+    ) {
+      formProcessor
+        .getInitialValues(context)
+        .then((values) => {
+          setInitialValues(values);
+          setIsLoadingInitialValues(false);
+        })
+        .catch((error) => {
+          console.error(error);
+          setError(error);
+          setIsLoadingInitialValues(false);
+        });
+    }
+  }, [formProcessor, isLoadingContextDependencies, context, initialValues]);
+
+  return { isLoadingInitialValues, initialValues, error };
+};
+
+export default useInitialValues;

package/src/hooks/usePatientData.ts

@@ -0,0 +1,32 @@
+import { usePatient } from '@openmrs/esm-framework';
+
+function calculateAge(birthDate: Date): number {
+  const today = new Date();
+  const yearsDiff = today.getFullYear() - birthDate.getFullYear();
+  if (
+    today.getMonth() < birthDate.getMonth() ||
+    (today.getMonth() === birthDate.getMonth() && today.getDate() < birthDate.getDate())
+  ) {
+    // subtract one year if the current date is before the birth date this year
+    return yearsDiff - 1;
+  } else {
+    return yearsDiff;
+  }
+}
+
+const patientGenderMap = {
+  female: 'F',
+  male: 'M',
+  other: 'O',
+  unknown: 'U',
+};
+
+export const usePatientData = (patientUuid) => {
+  const { patient, isLoading: isLoadingPatient, error: patientError } = usePatient(patientUuid);
+  if (patient && !isLoadingPatient) {
+    // This is for backward compatibility with the Angular form engine
+    patient['age'] = calculateAge(new Date(patient?.birthDate));
+    patient['sex'] = patientGenderMap[patient.gender] ?? 'U';
+  }
+  return { patient, isLoadingPatient, patientError };
+};

package/src/hooks/usePatientPrograms.ts

@@ -0,0 +1,38 @@
+import useSWR from 'swr';
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import type { FormSchema, ProgramsFetchResponse } from '../types';
+
+const useActiveProgramEnrollments = (patientUuid: string) => {
+  const customRepresentation = `custom:(uuid,display,program:(uuid,name,allWorkflows),dateEnrolled,dateCompleted,location:(uuid,display),states:(startDate,endDate,state:(uuid,name,retired,concept:(uuid),programWorkflow:(uuid)))`;
+  const apiUrl = `${restBaseUrl}/programenrollment?patient=${patientUuid}&v=${customRepresentation}`;
+
+  const { data, error, isLoading } = useSWR<{ data: ProgramsFetchResponse }, Error>(
+    patientUuid ? apiUrl : null,
+    openmrsFetch,
+  );
+
+  const sortedEnrollments =
+    data?.data?.results.length > 0
+      ? data?.data.results.sort((a, b) => (b.dateEnrolled > a.dateEnrolled ? 1 : -1))
+      : null;
+
+  const activePrograms = sortedEnrollments?.filter((enrollment) => !enrollment.dateCompleted);
+
+  return {
+    activePrograms,
+    error,
+    isLoading,
+  };
+};
+
+export const usePatientPrograms = (patientUuid: string, formJson: FormSchema) => {
+  const { activePrograms, error, isLoading } = useActiveProgramEnrollments(
+    formJson.meta?.programs?.hasProgramFields ? patientUuid : null,
+  );
+
+  return {
+    patientPrograms: activePrograms,
+    errorFetchingPatientPrograms: error,
+    isLoadingPatientPrograms: isLoading,
+  };
+};

package/src/hooks/usePostSubmissionActions.ts

@@ -0,0 +1,31 @@
+import { useEffect, useState } from 'react';
+import { getRegisteredPostSubmissionAction } from '../registry/registry';
+import { type PostSubmissionAction } from '../types';
+
+export interface PostSubmissionActionMeta {
+  postAction: PostSubmissionAction;
+  actionId: string;
+  config: Record<string, any>;
+  enabled?: string;
+}
+
+export function usePostSubmissionActions(
+  actionRefs: Array<{ actionId: string; enabled?: string; config?: Record<string, any> }>,
+): Array<PostSubmissionActionMeta> {
+  const [actions, setActions] = useState<Array<PostSubmissionActionMeta>>([]);
+
+  useEffect(() => {
+    const actionArray: Array<PostSubmissionActionMeta> = [];
+    if (actionRefs?.length) {
+      actionRefs.map((ref) => {
+        const actionId = typeof ref === 'string' ? ref : ref.actionId;
+        getRegisteredPostSubmissionAction(actionId)?.then((action) =>
+          actionArray.push({ postAction: action, config: ref.config, actionId: actionId, enabled: ref.enabled }),
+        );
+      });
+    }
+    setActions(actionArray);
+  }, [actionRefs]);
+
+  return actions;
+}

package/src/hooks/useProcessorDependencies.ts

@@ -0,0 +1,42 @@
+import { useEffect, useState } from 'react';
+import { type FormProcessorContextProps } from '../types';
+import { type FormProcessor } from '../processors/form-processor';
+import { reportError } from '../utils/error-utils';
+
+const useProcessorDependencies = (
+  formProcessor: FormProcessor,
+  context: Partial<FormProcessorContextProps>,
+  setContext: (context: FormProcessorContextProps) => void,
+) => {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState('');
+  const { loadDependencies } = formProcessor;
+
+  useEffect(() => {
+    let ignore = false;
+
+    if (loadDependencies) {
+      setIsLoading(true);
+      loadDependencies(context, setContext)
+        .then(() => {
+          if (!ignore) {
+            setIsLoading(false);
+          }
+        })
+        .catch((error) => {
+          if (!ignore) {
+            setError(error);
+            reportError(error, 'Encountered error while loading dependencies');
+          }
+        });
+    }
+
+    return () => {
+      ignore = true;
+    };
+  }, [loadDependencies]);
+
+  return { isLoading, error };
+};
+
+export default useProcessorDependencies;

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from './types';
+export * from './utils/forms-loader';
+export * from './registry/registry';
+export * from './constants';
+export * from './utils/boolean-utils';
+export * from './validators/form-validator';
+export * from './utils/form-helper';
+export * from './components/value/view/field-value-view.component';
+export * from './components/previous-value-review/previous-value-review.component';
+export * from './hooks/useFormJson';
+export { default as FormEngine } from './form-engine.component';

package/src/lifecycle.ts

@@ -0,0 +1,32 @@
+import { pageObserver } from './components/sidebar/page-observer';
+import { type FormFieldValueAdapter } from './types';
+
+const formFieldAdapters = new Set<FormFieldValueAdapter>();
+
+export function registerFormFieldAdaptersForCleanUp(formFieldAdaptersMap: Record<string, FormFieldValueAdapter>) {
+  if (formFieldAdaptersMap) {
+    Object.values(formFieldAdaptersMap).forEach((adapter) => {
+      formFieldAdapters.add(adapter);
+    });
+  }
+}
+/**
+ * Invoked on mounting the "FormEngine" component
+ */
+export function init() {
+}
+
+/**
+ * Invoked on unmounting the "FormEngine" component
+ */
+export function teardown() {
+  formFieldAdapters.forEach((adapter) => {
+    try {
+      adapter.tearDown();
+    } catch (error) {
+      // pass
+    }
+  });
+  formFieldAdapters.clear();
+  pageObserver.clear();
+}

package/src/post-submission-actions/mark-patient-deceased-action.ts

@@ -0,0 +1,68 @@
+import dayjs from 'dayjs';
+import { showSnackbar, translateFrom } from '@openmrs/esm-framework';
+import { markPatientAsDeceased } from '../api';
+import { extractErrorMessagesFromResponse } from '../utils/error-utils';
+import type { PostSubmissionAction, PatientDeathPayload } from '../types';
+import { formEngineAppName } from '../globals';
+
+export const MarkPatientAsDeceasedAction: PostSubmissionAction = {
+  applyAction: async function ({ patient, encounters, sessionMode }, config) {
+    const t = translateFrom.bind(null, formEngineAppName);
+    const encounter = encounters[0];
+
+    if (sessionMode === 'view') {
+      return;
+    }
+
+    if (patient._deceasedBoolean || patient.deceasedDateTime) {
+      throw new Error(t('patientIsAlreadyMarkedAsDeceased', 'Patient is already marked as deceased'));
+    }
+
+    const causeOfDeathQuestionId = config.causeOfDeathQuestionId;
+    const dateOfDeathQuestionId = config.dateOfDeathQuestionId;
+    if (!causeOfDeathQuestionId) {
+      throw new Error(t('causeOfDeathQuestionIdIsNotConfigured', 'Cause of death question ID is not configured'));
+    }
+    if (!dateOfDeathQuestionId) {
+      throw new Error(t('dateOfDeathQuestionIdIsNotConfigured', 'Date of death question ID is not configured'));
+    }
+
+    const causeOfDeath: string = encounter.obs?.find((item) => {
+      return item.formFieldPath.includes(causeOfDeathQuestionId);
+    })?.value.uuid;
+    const dateOfDeath: string = encounter.obs?.find((item) =>
+      item.formFieldPath.includes(dateOfDeathQuestionId),
+    )?.value;
+
+    if (!causeOfDeath) {
+      return;
+    }
+
+    const deathPayload: PatientDeathPayload = {
+      dead: true,
+      causeOfDeath,
+      deathDate: dateOfDeath ?? dayjs().format(),
+    };
+    const abortController = new AbortController();
+
+    markPatientAsDeceased(t, patient.id, deathPayload, abortController).then(
+      (response) => {
+        showSnackbar({
+          kind: 'success',
+          title: t('successfullyMarkedAsDeceased', 'The patient has successfully been marked as deceased'),
+          isLowContrast: true,
+        });
+      },
+      (err) => {
+        showSnackbar({
+          title: t('errorMarkingAsDeceased', 'Error marking patient as deceased'),
+          subtitle: extractErrorMessagesFromResponse(err).join(', '),
+          kind: 'error',
+          isLowContrast: false,
+        });
+      },
+    );
+  },
+};
+
+export default MarkPatientAsDeceasedAction;

package/src/post-submission-actions/program-enrollment-action.ts

@@ -0,0 +1,137 @@
+import dayjs from 'dayjs';
+import { showSnackbar, translateFrom } from '@openmrs/esm-framework';
+import { getPatientEnrolledPrograms, saveProgramEnrollment } from '../api';
+import { type PostSubmissionAction, type PatientProgramPayload } from '../types';
+import { formEngineAppName } from '../globals';
+import { extractErrorMessagesFromResponse } from '../utils/error-utils';
+import { type TOptions } from 'i18next';
+
+export const ProgramEnrollmentSubmissionAction: PostSubmissionAction = {
+  applyAction: async function ({ patient, encounters, sessionMode }, config) {
+    const encounter = encounters[0];
+    const encounterLocation = encounter.location['uuid'];
+    const t = (key: string, defaultValue: string, options?: Omit<TOptions, 'ns' | 'defaultValue'>) =>
+      translateFrom(formEngineAppName, key, defaultValue, options);
+    const programUuid = config.programUuid;
+
+    if (sessionMode === 'view') {
+      return;
+    }
+    if (!programUuid) {
+      throw new Error('Program UUID not configured');
+    }
+
+    const enrollmentDate = encounter.obs?.find((item) =>
+      item.formFieldPath.includes(config.enrollmentDate || null),
+    )?.value;
+    const completionDate = encounter.obs?.find((item) =>
+      item.formFieldPath.includes(config.completionDate || null),
+    )?.value;
+
+    const abortController = new AbortController();
+    let payload: PatientProgramPayload = {
+      patient: patient.id,
+      program: programUuid,
+      dateEnrolled: enrollmentDate ?? dayjs().format(),
+      location: encounterLocation,
+    };
+    const patientPrograms = await getPatientEnrolledPrograms(patient.id);
+    const existingProgramEnrollment = patientPrograms?.results.find(
+      (enrollment) => enrollment.program.uuid === programUuid && !enrollment.dateCompleted,
+    );
+
+    if (config.completionDate) {
+      if (!completionDate) {
+        throw new Error('Completion date was not found in the encounter');
+      }
+      if (existingProgramEnrollment) {
+        payload = {
+          uuid: existingProgramEnrollment.uuid,
+          dateCompleted: updateTimeToNow(completionDate),
+        };
+      } else {
+        showSnackbar({
+          title: t('enrollmentDiscontinuationNotAllowed', 'Enrollment discontinuation not allowed'),
+          subtitle: t('cannotDiscontinueEnrollment', 'Cannot discontinue an enrollment that does not exist'),
+          kind: 'error',
+          isLowContrast: false,
+        });
+        return;
+      }
+    }
+
+    if (existingProgramEnrollment) {
+      if (!existingProgramEnrollment.dateCompleted && !completionDate) {
+        // The patient is already enrolled in the program and there is no completion date provided.
+        if (sessionMode === 'enter') {
+          showSnackbar({
+            title: t('enrollmentNotAllowed', 'Enrollment not allowed'),
+            subtitle: t(
+              'alreadyEnrolledDescription',
+              'This patient is already enrolled in the selected program and cannot be enrolled again.',
+            ),
+            kind: 'error',
+            isLowContrast: false,
+          });
+        }
+        return;
+      } else if (existingProgramEnrollment.dateCompleted) {
+        // The enrollment has already been completed
+        if (sessionMode === 'enter') {
+          showSnackbar({
+            title: t('enrollmentAlreadyDiscontinued', 'Enrollment already discontinued'),
+            subtitle: t(
+              'alreadyDiscontinuedDescription',
+              'This patient is already enrolled in the selected program and has already been discontinued.',
+            ),
+            kind: 'error',
+            isLowContrast: false,
+          });
+        }
+        return;
+      }
+    }
+    saveProgramEnrollment(payload, abortController).then(
+      (response) => {
+        showSnackbar({
+          kind: 'success',
+          title: getSnackTitle(t, response),
+          isLowContrast: true,
+        });
+      },
+      (err) => {
+        showSnackbar({
+          title: t('errorSavingEnrollment', 'Error saving enrollment'),
+          subtitle: extractErrorMessagesFromResponse(err).join(', '),
+          kind: 'error',
+          isLowContrast: false,
+        });
+      },
+    );
+  },
+};
+
+function getSnackTitle(t, response) {
+  if (response.data.dateCompleted) {
+    return t('enrollmentDiscontinued', "The patient's program enrollment has been successfully discontinued.");
+  }
+  return t('enrolledToProgram', 'The patient has been successfully enrolled in the program.');
+}
+
+function updateTimeToNow(dateString) {
+  // Check if the input date string has the time set to midnight (00:00:00.000+0000)
+  if (!dateString.endsWith('T00:00:00.000+0000')) {
+    return dateString;
+  }
+  const now = dayjs();
+  const originalDate = dayjs(dateString);
+  const updatedDate = originalDate
+    .hour(now.hour())
+    .minute(now.minute())
+    .second(now.second())
+    .millisecond(now.millisecond());
+
+  return updatedDate.format();
+}
+
+export default ProgramEnrollmentSubmissionAction;