@openmrs/esm-form-engine-lib 2.1.0-pre.1362

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

@@ -0,0 +1,138 @@
+import dayjs from 'dayjs';
+import { showSnackbar, translateFrom } from '@openmrs/esm-framework';
+import { getPatientEnrolledPrograms, saveProgramEnrollment } from '../api';
+import { type PostSubmissionAction, type PatientProgramPayload } from '../types';
+import { moduleName } from '../globals';
+import { extractErrorMessagesFromResponse } from '../utils/error-utils';
+
+export const ProgramEnrollmentSubmissionAction: PostSubmissionAction = {
+  applyAction: async function ({ patient, encounters, sessionMode }, config) {
+    const encounter = encounters[0];
+    const encounterLocation = encounter.location['uuid'];
+    const translateFn = (key, defaultValue?) => translateFrom(moduleName, key, defaultValue);
+    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: translateFn('enrollmentDiscontinuationNotAllowed', 'Enrollment discontinuation not allowed'),
+          subtitle: translateFn('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: translateFn('enrollmentNotAllowed', 'Enrollment not allowed'),
+            subtitle: translateFn(
+              '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: translateFn('enrollmentAlreadyDiscontinued', 'Enrollment already discontinued'),
+            subtitle: translateFn(
+              '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(translateFn, response),
+          isLowContrast: true,
+        });
+      },
+      (err) => {
+        showSnackbar({
+          title: translateFn('errorSavingEnrollment', 'Error saving enrollment'),
+          subtitle: extractErrorMessagesFromResponse(err).join(', '),
+          kind: 'error',
+          isLowContrast: false,
+        });
+      },
+    );
+  },
+};
+
+function getSnackTitle(translateFn, response) {
+  if (response.data.dateCompleted) {
+    return translateFn(
+      'enrollmentDiscontinued',
+      "The patient's program enrollment has been successfully discontinued.",
+    );
+  }
+  return translateFn('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;

package/src/processors/encounter/encounter-form-processor.ts

@@ -0,0 +1,337 @@
+import {
+  type ValueAndDisplay,
+  type FormField,
+  type FormProcessorContextProps,
+  type FormPage,
+  type FormSection,
+} from '../../types';
+import { usePatientPrograms } from '../../hooks/usePatientPrograms';
+import { useEffect, useState } from 'react';
+import { useEncounter } from '../../hooks/useEncounter';
+import { isEmpty } from '../../validators/form-validator';
+import { type FormSchema } from '../../types';
+import { type FormContextProps } from '../../provider/form-provider';
+import { FormProcessor } from '../form-processor';
+import {
+  getMutableSessionProps,
+  hydrateRepeatField,
+  inferInitialValueFromDefaultFieldValue,
+  prepareEncounter,
+  preparePatientIdentifiers,
+  preparePatientPrograms,
+  saveAttachments,
+  savePatientIdentifiers,
+  savePatientPrograms,
+} from './encounter-processor-helper';
+import { type OpenmrsResource, showSnackbar, translateFrom } from '@openmrs/esm-framework';
+import { moduleName } from '../../globals';
+import { extractErrorMessagesFromResponse } from '../../utils/error-utils';
+import { getPreviousEncounter, saveEncounter } from '../../api';
+import { useEncounterRole } from '../../hooks/useEncounterRole';
+import { type FormNode, evaluateAsyncExpression, evaluateExpression } from '../../utils/expression-runner';
+import { hasRendering } from '../../utils/common-utils';
+
+function useCustomHooks(context: Partial<FormProcessorContextProps>) {
+  const [isLoading, setIsLoading] = useState(true);
+  const { encounter, isLoading: isLoadingEncounter } = useEncounter(context.formJson);
+  const { encounterRole, isLoading: isLoadingEncounterRole } = useEncounterRole();
+  const { isLoading: isLoadingPatientPrograms, patientPrograms } = usePatientPrograms(
+    context.patient?.id,
+    context.formJson,
+  );
+
+  useEffect(() => {
+    setIsLoading(isLoadingPatientPrograms || isLoadingEncounter || isLoadingEncounterRole);
+  }, [isLoadingPatientPrograms, isLoadingEncounter, isLoadingEncounterRole]);
+
+  return {
+    data: { encounter, patientPrograms, encounterRole },
+    isLoading,
+    error: null,
+    updateContext: (setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>) => {
+      setContext((context) => {
+        context.processor.domainObjectValue = encounter as OpenmrsResource;
+        return {
+          ...context,
+          domainObjectValue: encounter as OpenmrsResource,
+          customDependencies: {
+            ...context.customDependencies,
+            patientPrograms: patientPrograms,
+            defaultEncounterRole: encounterRole,
+          },
+        };
+      });
+    },
+  };
+}
+
+const emptyValues = {
+  checkbox: [],
+  toggle: false,
+  text: '',
+};
+
+const contextInitializableTypes = [
+  'encounterProvider',
+  'encounterDatetime',
+  'encounterLocation',
+  'patientIdentifier',
+  'encounterRole',
+];
+export class EncounterFormProcessor extends FormProcessor {
+  prepareFormSchema(schema: FormSchema) {
+    schema.pages.forEach((page) => {
+      page.sections.forEach((section) => {
+        section.questions.forEach((question) => {
+          prepareFormField(question, section, page, schema);
+        });
+      });
+    });
+
+    function prepareFormField(field: FormField, section: FormSection, page: FormPage, schema: FormSchema) {
+      // inherit inlineRendering and readonly from parent section and page if not set
+      field.inlineRendering =
+        field.inlineRendering ?? section.inlineRendering ?? page.inlineRendering ?? schema.inlineRendering;
+      field.readonly = field.readonly ?? section.readonly ?? page.readonly ?? schema.readonly;
+      if (field.questionOptions?.rendering == 'fixed-value' && !field.meta.fixedValue) {
+        field.meta.fixedValue = field.value;
+        delete field.value;
+      }
+      if (field.questionOptions?.rendering == 'group') {
+        field.questions?.forEach((child) => {
+          child.readonly = child.readonly ?? field.readonly;
+          return prepareFormField(child, section, page, schema);
+        });
+      }
+    }
+    return schema;
+  }
+
+  async processSubmission(context: FormContextProps, abortController: AbortController) {
+    const { encounterRole, encounterProvider, encounterDate, encounterLocation } = getMutableSessionProps(context);
+    const translateFn = (key, defaultValue?) => translateFrom(moduleName, key, defaultValue);
+    const patientIdentifiers = preparePatientIdentifiers(context.formFields, encounterLocation);
+    const encounter = prepareEncounter(context, encounterDate, encounterRole, encounterProvider, encounterLocation);
+
+    // save patient identifiers
+    try {
+      await Promise.all(savePatientIdentifiers(context.patient, patientIdentifiers));
+      if (patientIdentifiers?.length) {
+        showSnackbar({
+          title: translateFn('patientIdentifiersSaved', 'Patient identifier(s) saved successfully'),
+          kind: 'success',
+          isLowContrast: true,
+        });
+      }
+    } catch (error) {
+      const errorMessages = extractErrorMessagesFromResponse(error);
+      return Promise.reject({
+        title: translateFn('errorSavingPatientIdentifiers', 'Error saving patient identifiers'),
+        description: errorMessages.join(', '),
+        kind: 'error',
+        critical: true,
+      });
+    }
+
+    // save patient programs
+    try {
+      const programs = preparePatientPrograms(
+        context.formFields,
+        context.patient,
+        context.customDependencies.patientPrograms,
+      );
+      const savedPrograms = await await savePatientPrograms(programs);
+      if (savedPrograms?.length) {
+        showSnackbar({
+          title: translateFn('patientProgramsSaved', 'Patient program(s) saved successfully'),
+          kind: 'success',
+          isLowContrast: true,
+        });
+      }
+    } catch (error) {
+      const errorMessages = extractErrorMessagesFromResponse(error);
+      return Promise.reject({
+        title: translateFn('errorSavingPatientPrograms', 'Error saving patient program(s)'),
+        description: errorMessages.join(', '),
+        kind: 'error',
+        critical: true,
+      });
+    }
+
+    // save encounter
+    try {
+      const { data: savedEncounter } = await saveEncounter(abortController, encounter, encounter.uuid);
+      const saveOrders = savedEncounter.orders.map((order) => order.orderNumber);
+      if (saveOrders.length) {
+        showSnackbar({
+          title: translateFn('ordersSaved', 'Order(s) saved successfully'),
+          subtitle: saveOrders.join(', '),
+          kind: 'success',
+          isLowContrast: true,
+        });
+      }
+      // handle attachments
+      try {
+        const attachmentsResponse = await Promise.all(
+          saveAttachments(context.formFields, savedEncounter, abortController),
+        );
+        if (attachmentsResponse?.length) {
+          showSnackbar({
+            title: translateFn('attachmentsSaved', 'Attachment(s) saved successfully'),
+            kind: 'success',
+            isLowContrast: true,
+          });
+        }
+      } catch (error) {
+        const errorMessages = extractErrorMessagesFromResponse(error);
+        return Promise.reject({
+          title: translateFn('errorSavingAttachments', 'Error saving attachment(s)'),
+          description: errorMessages.join(', '),
+          kind: 'error',
+          critical: true,
+        });
+      }
+      return savedEncounter;
+    } catch (error) {
+      const errorMessages = extractErrorMessagesFromResponse(error);
+      return Promise.reject({
+        title: translateFn('errorSavingEncounter', 'Error saving encounter'),
+        description: errorMessages.join(', '),
+        kind: 'error',
+        critical: true,
+      });
+    }
+  }
+
+  getCustomHooks() {
+    return { useCustomHooks };
+  }
+
+  async getInitialValues(context: FormProcessorContextProps) {
+    const { domainObjectValue: encounter, formFields, formFieldAdapters } = context;
+    const initialValues = {};
+    const repeatableFields = [];
+    if (encounter) {
+      const filteredFields = formFields.filter((field) => isEmpty(field.meta?.previousValue));
+      await Promise.all(
+        filteredFields.map(async (field) => {
+          const adapter = formFieldAdapters[field.type];
+          if (adapter) {
+            if (hasRendering(field, 'repeating') && !field.meta?.repeat?.isClone) {
+              repeatableFields.push(field);
+            }
+            let value = null;
+            try {
+              value = await adapter.getInitialValue(field, encounter, context);
+            } catch (error) {
+              console.error(error);
+            }
+            if (field.type === 'obsGroup') {
+              return;
+            }
+            if (!isEmpty(value)) {
+              initialValues[field.id] = value;
+            } else if (!isEmpty(field.questionOptions.defaultValue)) {
+              initialValues[field.id] = inferInitialValueFromDefaultFieldValue(field);
+            } else {
+              initialValues[field.id] = emptyValues[field.questionOptions.rendering] ?? '';
+            }
+            if (field.questionOptions.calculate?.calculateExpression) {
+              await evaluateCalculateExpression(field, initialValues, context);
+            }
+          } else {
+            console.warn(`No adapter found for field type ${field.type}`);
+          }
+        }),
+      );
+      const flattenedRepeatableFields = await Promise.all(
+        repeatableFields.flatMap((field) => hydrateRepeatField(field, encounter, initialValues, context)),
+      ).then((results) => results.flat());
+      formFields.push(...flattenedRepeatableFields);
+    } else {
+      const filteredFields = formFields.filter(
+        (field) => field.questionOptions.rendering !== 'group' && field.type !== 'obsGroup',
+      );
+      await Promise.all(
+        filteredFields.map(async (field) => {
+          const adapter = formFieldAdapters[field.type];
+          initialValues[field.id] = emptyValues[field.questionOptions.rendering] ?? null;
+          if (field.questionOptions.calculate?.calculateExpression) {
+            await evaluateCalculateExpression(field, initialValues, context);
+          }
+          if (isEmpty(initialValues[field.id]) && contextInitializableTypes.includes(field.type)) {
+            try {
+              initialValues[field.id] = await adapter.getInitialValue(field, null, context);
+            } catch (error) {
+              console.error(error);
+            }
+          }
+        }),
+      );
+    }
+    return initialValues;
+  }
+
+  async loadDependencies(
+    context: FormContextProps,
+    setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>,
+  ) {
+    const { patient, formJson } = context;
+    const encounter = await getPreviousEncounter(patient?.id, formJson.encounterType);
+    setContext((context) => {
+      return {
+        ...context,
+        previousDomainObjectValue: encounter,
+      };
+    });
+    return context;
+  }
+
+  async getHistoricalValue(field: FormField, context: FormContextProps): Promise<ValueAndDisplay> {
+    const {
+      formFields,
+      sessionMode,
+      patient,
+      methods: { getValues },
+      formFieldAdapters,
+      previousDomainObjectValue,
+    } = context;
+    const node: FormNode = { value: field, type: 'field' };
+    const adapter = formFieldAdapters[field.type];
+    if (field.historicalExpression) {
+      const value = await evaluateAsyncExpression(field.historicalExpression, node, formFields, getValues(), {
+        mode: sessionMode,
+        patient: patient,
+        previousEncounter: previousDomainObjectValue,
+      });
+      return value;
+    }
+    if (previousDomainObjectValue && field.questionOptions.enablePreviousValue) {
+      return await adapter.getPreviousValue(field, previousDomainObjectValue, context);
+    }
+    return null;
+  }
+}
+
+async function evaluateCalculateExpression(
+  field: FormField,
+  values: Record<string, any>,
+  formContext: FormProcessorContextProps,
+) {
+  const { formFields, sessionMode, patient } = formContext;
+  const expression = field.questionOptions.calculate.calculateExpression;
+  const node: FormNode = { value: field, type: 'field' };
+  const context = {
+    mode: sessionMode,
+    patient: patient,
+  };
+  let value = null;
+  if (field.questionOptions.calculate.calculateExpression.includes('resolve(')) {
+    value = await evaluateAsyncExpression(expression, node, formFields, values, context);
+  } else {
+    value = evaluateExpression(expression, node, formFields, values, context);
+  }
+  if (!isEmpty(value)) {
+    values[field.id] = value;
+  }
+}