@olaboot/esm-form-engine-lib 4.1.0

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

@@ -0,0 +1,387 @@
+import {
+  type AttachmentFieldValue,
+  type FormField,
+  type FormProcessorContextProps,
+  type OpenmrsEncounter,
+  type OpenmrsObs,
+  type PatientIdentifier,
+  type PatientProgram,
+  type PatientProgramPayload,
+  type PersonAttribute,
+} from '../../types';
+import { createAttachment, savePatientIdentifier, savePersonAttribute, saveProgramEnrollment } from '../../api';
+import { hasRendering, hasSubmission } from '../../utils/common-utils';
+import dayjs from 'dayjs';
+import { assignedObsIds, constructObs, voidObs } from '../../adapters/obs-adapter';
+import { type FormContextProps } from '../../provider/form-provider';
+import { ConceptTrue } from '../../constants';
+import { DefaultValueValidator } from '../../validators/default-value-validator';
+import { cloneRepeatField } from '../../components/repeat/helpers';
+import { assignedOrderIds } from '../../adapters/orders-adapter';
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import { assignedDiagnosesIds } from '../../adapters/encounter-diagnosis-adapter';
+
+export function prepareEncounter(
+  context: FormContextProps,
+  encounterDate: Date,
+  encounterRole: string,
+  encounterProvider: string,
+  location: string,
+) {
+  const { patient, formJson, domainObjectValue: encounter, formFields, visit, deletedFields } = context;
+  const allFormFields = [...formFields, ...deletedFields];
+  const obsForSubmission = [];
+  prepareObs(obsForSubmission, allFormFields);
+  const ordersForSubmission = prepareOrders(allFormFields);
+  const diagnosesForSubmission = prepareDiagnosis(allFormFields);
+
+  let encounterForSubmission: OpenmrsEncounter = {};
+
+  if (encounter) {
+    Object.assign(encounterForSubmission, encounter);
+    // update encounter providers
+    const hasCurrentProvider =
+      encounterForSubmission.encounterProviders.findIndex(
+        (encProvider) => encProvider.provider.uuid == encounterProvider,
+      ) !== -1;
+    if (!hasCurrentProvider) {
+      encounterForSubmission.encounterProviders = [
+        ...encounterForSubmission.encounterProviders,
+        {
+          provider: encounterProvider,
+          encounterRole,
+        },
+      ];
+    }
+    // TODO: Question: Should we be editing the location, form and visit here?
+    encounterForSubmission.encounterDatetime = encounterDate;
+    encounterForSubmission.location = location;
+    encounterForSubmission.form = {
+      uuid: formJson.uuid,
+    };
+    if (visit) {
+      encounterForSubmission.visit = visit.uuid;
+    }
+    encounterForSubmission.obs = obsForSubmission;
+    encounterForSubmission.orders = ordersForSubmission;
+    encounterForSubmission.diagnoses = diagnosesForSubmission;
+  } else {
+    encounterForSubmission = {
+      patient: patient.id,
+      encounterDatetime: encounterDate,
+      location: location,
+      encounterType: formJson.encounterType,
+      encounterProviders: [
+        {
+          provider: encounterProvider,
+          encounterRole,
+        },
+      ],
+      obs: obsForSubmission,
+      form: {
+        uuid: formJson.uuid,
+      },
+      visit: visit?.uuid,
+      orders: ordersForSubmission,
+      diagnoses: diagnosesForSubmission,
+    };
+  }
+  return encounterForSubmission;
+}
+
+export function preparePatientIdentifiers(fields: FormField[], encounterLocation: string): PatientIdentifier[] {
+  return fields
+    .filter((field) => field.type === 'patientIdentifier' && hasSubmission(field))
+    .map((field) => field.meta.submission.newValue);
+}
+
+export function savePatientIdentifiers(patient: fhir.Patient, identifiers: PatientIdentifier[]) {
+  return identifiers.map((patientIdentifier) => {
+    return savePatientIdentifier(patientIdentifier, patient.id);
+  });
+}
+
+export function preparePersonAttributes(fields: FormField[]): PersonAttribute[] {
+  return fields
+    .filter((field) => field.type === 'personAttribute' && hasSubmission(field))
+    .map((field) => field.meta.submission.newValue);
+}
+
+export function savePersonAttributes(patient: fhir.Patient, attributes: PersonAttribute[]) {
+  return attributes.map((personAttribute) => {
+    return savePersonAttribute(personAttribute, patient.id);
+  });
+}
+
+export function preparePatientPrograms(
+  fields: FormField[],
+  patient: fhir.Patient,
+  currentPatientPrograms: Array<PatientProgram>,
+): Array<PatientProgramPayload> {
+  const programStateFields = fields.filter((field) => field.type === 'programState' && hasSubmission(field));
+  const programMap = new Map<string, PatientProgramPayload>();
+  programStateFields.forEach((field) => {
+    const programUuid = field.questionOptions.programUuid;
+    const newState = field.meta.submission.newValue;
+    const existingProgramEnrollment = currentPatientPrograms.find((program) => program.program.uuid === programUuid);
+
+    if (existingProgramEnrollment) {
+      if (programMap.has(programUuid)) {
+        programMap.get(programUuid).states.push(newState);
+      } else {
+        programMap.set(programUuid, {
+          uuid: existingProgramEnrollment.uuid,
+          states: [newState],
+        });
+      }
+    } else {
+      if (programMap.has(programUuid)) {
+        programMap.get(programUuid).states.push(newState);
+      } else {
+        programMap.set(programUuid, {
+          patient: patient.id,
+          program: programUuid,
+          states: [newState],
+          dateEnrolled: dayjs().format(),
+        });
+      }
+    }
+  });
+  return Array.from(programMap.values());
+}
+
+export function savePatientPrograms(patientPrograms: PatientProgramPayload[]) {
+  const ac = new AbortController();
+  return Promise.all(patientPrograms.map((programPayload) => saveProgramEnrollment(programPayload, ac)));
+}
+
+export function saveAttachments(fields: FormField[], encounter: OpenmrsEncounter, abortController: AbortController) {
+  const complexFields = fields?.filter((field) => field?.questionOptions.rendering === 'file' && hasSubmission(field));
+
+  if (!complexFields?.length) {
+    return [];
+  }
+
+  const allPromises = complexFields.flatMap((field) => {
+    const patientUuid = typeof encounter?.patient === 'string' ? encounter?.patient : encounter?.patient?.uuid;
+    const attachments = (field.meta.submission.newValue as AttachmentFieldValue[]) ?? [];
+    return attachments.map((attachment) => createAttachment(patientUuid, encounter.uuid, attachment));
+  });
+
+  return Promise.all(allPromises);
+}
+
+export function getMutableSessionProps(context: FormContextProps) {
+  const { formFields, location, currentProvider, customDependencies, domainObjectValue: encounter } = context;
+  const { defaultEncounterRole } = customDependencies;
+  const encounterRole =
+    formFields.find((field) => field.type === 'encounterRole')?.meta.submission?.newValue || defaultEncounterRole?.uuid;
+  const encounterProvider =
+    formFields.find((field) => field.type === 'encounterProvider')?.meta.submission?.newValue || currentProvider.uuid;
+  const encounterDate = formFields.find((field) => field.type === 'encounterDatetime')?.meta.submission?.newValue;
+  const encounterLocation =
+    formFields.find((field) => field.type === 'encounterLocation')?.meta.submission?.newValue ||
+    encounter?.location?.uuid ||
+    location.uuid;
+  return {
+    encounterRole: encounterRole as string,
+    encounterProvider: encounterProvider as string,
+    encounterDate: encounterDate as Date,
+    encounterLocation: encounterLocation as string,
+  };
+}
+
+// Helpers
+
+function prepareObs(obsForSubmission: OpenmrsObs[], fields: FormField[]) {
+  fields.filter((field) => hasSubmittableObs(field)).forEach((field) => processObsField(obsForSubmission, field));
+}
+
+function processObsField(obsForSubmission: OpenmrsObs[], field: FormField) {
+  if ((field.isHidden || field.isParentHidden) && field.meta.initialValue.omrsObject) {
+    const valuesArray = Array.isArray(field.meta.initialValue.omrsObject)
+      ? field.meta.initialValue.omrsObject
+      : [field.meta.initialValue.omrsObject];
+    addObsToList(
+      obsForSubmission,
+      valuesArray.map((obs) => voidObs(obs)),
+    );
+    return;
+  }
+
+  if (field.type === 'obsGroup') {
+    processObsGroup(obsForSubmission, field);
+    return;
+  }
+
+  // new attachments will be processed later
+  if (!hasRendering(field, 'file')) {
+    addObsToList(obsForSubmission, field.meta.submission.newValue);
+  }
+  addObsToList(obsForSubmission, field.meta.submission.voidedValue);
+}
+
+function processObsGroup(obsForSubmission: OpenmrsObs[], groupField: FormField) {
+  if (groupField.meta.submission?.voidedValue) {
+    addObsToList(obsForSubmission, groupField.meta.submission.voidedValue);
+    return;
+  }
+
+  const obsGroup = constructObs(groupField, null);
+  if (groupField.meta.initialValue?.omrsObject) {
+    obsGroup.uuid = (groupField.meta.initialValue.omrsObject as OpenmrsResource).uuid;
+  }
+
+  groupField.questions.forEach((nestedField) => {
+    if (nestedField.type === 'obsGroup') {
+      const nestedObsGroup: OpenmrsObs[] = [];
+      processObsGroup(nestedObsGroup, nestedField);
+      addObsToList(obsGroup.groupMembers, nestedObsGroup);
+    } else if (hasSubmission(nestedField)) {
+      addObsToList(obsGroup.groupMembers, nestedField.meta.submission.newValue);
+      addObsToList(obsGroup.groupMembers, nestedField.meta.submission.voidedValue);
+    }
+  });
+
+  if (obsGroup.groupMembers?.length || obsGroup.voided) {
+    addObsToList(obsForSubmission, obsGroup);
+  }
+}
+
+function prepareOrders(fields: FormField[]) {
+  return fields
+    .filter((field) => field.type === 'testOrder' && hasSubmission(field))
+    .flatMap((field) => [field.meta.submission.newValue, field.meta.submission.voidedValue])
+    .filter((o) => o);
+}
+
+function addObsToList(obsList: Array<Partial<OpenmrsObs>>, obs: Partial<OpenmrsObs>) {
+  if (!obs) {
+    return;
+  }
+  if (Array.isArray(obs)) {
+    obsList.push(...obs);
+  } else {
+    obsList.push(obs);
+  }
+}
+
+function hasSubmittableObs(field: FormField) {
+  const {
+    questionOptions: { isTransient },
+    type,
+  } = field;
+
+  if (isTransient || !['obs', 'obsGroup'].includes(type) || field.meta.groupId) {
+    return false;
+  }
+  if ((field.isHidden || field.isParentHidden) && field.meta.initialValue?.omrsObject) {
+    return true;
+  }
+  return !field.isHidden && !field.isParentHidden && (type === 'obsGroup' || hasSubmission(field));
+}
+
+export function inferInitialValueFromDefaultFieldValue(field: FormField) {
+  if (field.questionOptions.rendering == 'toggle' && typeof field.questionOptions.defaultValue != 'boolean') {
+    return field.questionOptions.defaultValue == ConceptTrue;
+  }
+
+  // validate default value
+  const errors = DefaultValueValidator.validate(field, field.questionOptions.defaultValue);
+  if (errors.length) {
+    console.error(
+      `Default value validation errors for field "${field.id}" with value "${field.questionOptions.defaultValue}":`,
+      errors,
+    );
+    return null;
+  }
+  return field.questionOptions.defaultValue;
+}
+
+export async function hydrateRepeatField(
+  field: FormField,
+  encounter: OpenmrsEncounter,
+  initialValues: Record<string, any>,
+  context: FormProcessorContextProps,
+): Promise<FormField[]> {
+  let counter = 1;
+  const { formFieldAdapters } = context;
+  const unMappedGroups = encounter.obs.filter(
+    (obs) =>
+      obs.concept.uuid === field.questionOptions.concept &&
+      obs.uuid != (field.meta.initialValue?.omrsObject as OpenmrsResource)?.uuid &&
+      !assignedObsIds.includes(obs.uuid),
+  );
+  const unMappedOrders = encounter.orders.filter((order) => {
+    const availableOrderables = field.questionOptions.answers?.map((answer) => answer.concept) || [];
+    return availableOrderables.includes(order.concept?.uuid) && !assignedOrderIds.includes(order.uuid);
+  });
+  if (field.type === 'testOrder') {
+    return Promise.all(
+      unMappedOrders
+        .filter((order) => !order.voided)
+        .map(async (order) => {
+          const clone = cloneRepeatField(field, order, counter++);
+          initialValues[clone.id] = await formFieldAdapters[field.type].getInitialValue(
+            clone,
+            { orders: [order] } as any,
+            context,
+          );
+          return clone;
+        }),
+    );
+  }
+
+  const unMappedDiagnoses = encounter.diagnoses.filter((diagnosis) => {
+    return (
+      !diagnosis.voided &&
+      !assignedDiagnosesIds.includes(diagnosis?.diagnosis?.coded.uuid) &&
+      diagnosis.formFieldPath.startsWith(`rfe-forms-${field.id}_`)
+    );
+  });
+
+  if (field.type === 'diagnosis') {
+    return Promise.all(
+      unMappedDiagnoses.map(async (diagnosis) => {
+        const idSuffix = parseInt(diagnosis.formFieldPath.split('_')[1]);
+        const clone = cloneRepeatField(field, diagnosis, idSuffix);
+        initialValues[clone.id] = await formFieldAdapters[field.type].getInitialValue(
+          clone,
+          { diagnoses: [diagnosis] } as any,
+          context,
+        );
+        if (!assignedDiagnosesIds.includes(diagnosis.diagnosis.coded.uuid)) {
+          assignedDiagnosesIds.push(diagnosis.diagnosis.coded.uuid);
+        }
+
+        return clone;
+      }),
+    );
+  }
+  // handle obs groups
+  return Promise.all(
+    unMappedGroups.map(async (group) => {
+      const clone = cloneRepeatField(field, group, counter++);
+      await Promise.all(
+        clone.questions.map(async (childField) => {
+          initialValues[childField.id] = await formFieldAdapters[field.type].getInitialValue(
+            childField,
+            { obs: [group] } as any,
+            context,
+          );
+        }),
+      );
+      assignedObsIds.push(group.uuid);
+      return [clone, ...clone.questions];
+    }),
+  ).then((results) => results.flat());
+}
+
+function prepareDiagnosis(fields: FormField[]) {
+  const diagnoses = fields
+    .filter((field) => field.type === 'diagnosis' && hasSubmission(field))
+    .map((field) => field.meta.submission.newValue || field.meta.submission.voidedValue)
+    .filter((o) => o);
+
+  return diagnoses;
+}

package/src/processors/form-processor.ts

@@ -0,0 +1,40 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import { type FormContextProps } from '../provider/form-provider';
+import { type ValueAndDisplay, type FormField, type FormSchema, type FormProcessorContextProps } from '../types';
+
+export type FormProcessorConstructor = new (...args: ConstructorParameters<typeof FormProcessor>) => FormProcessor;
+
+export type GetCustomHooksResponse = {
+  useCustomHooks: (context: Partial<FormProcessorContextProps>) => {
+    data: any;
+    isLoading: boolean;
+    error: any;
+    updateContext: (setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>) => void;
+  };
+};
+
+export abstract class FormProcessor {
+  formJson: FormSchema;
+  domainObjectValue: OpenmrsResource;
+
+  constructor(formJson: FormSchema) {
+    this.formJson = formJson;
+  }
+
+  getDomainObject() {
+    return this.domainObjectValue;
+  }
+
+  async loadDependencies(
+    context: Partial<FormProcessorContextProps>,
+    setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>,
+  ): Promise<Record<string, any>> {
+    return Promise.resolve({});
+  }
+
+  abstract getHistoricalValue(field: FormField, context: FormContextProps): Promise<ValueAndDisplay>;
+  abstract processSubmission(context: FormContextProps, abortController: AbortController): Promise<OpenmrsResource>;
+  abstract getInitialValues(context: FormProcessorContextProps): Promise<Record<string, any>>;
+  abstract getCustomHooks(): GetCustomHooksResponse;
+  abstract prepareFormSchema(schema: FormSchema): FormSchema;
+}

package/src/provider/form-factory-helper.ts

@@ -0,0 +1,106 @@
+import { type OpenmrsResource, showSnackbar } from '@openmrs/esm-framework';
+import { type FormContextProps } from './form-provider';
+import { extractErrorMessagesFromResponse } from '../utils/error-utils';
+import { evaluatePostSubmissionExpression } from '../utils/post-submission-action-helper';
+import { type PostSubmissionActionMeta } from '../hooks/usePostSubmissionActions';
+import { type TFunction } from 'i18next';
+import { type SessionMode } from '../types';
+
+export function validateForm(context: FormContextProps) {
+  const {
+    formFields,
+    formFieldValidators,
+    patient,
+    sessionMode,
+    addInvalidField,
+    updateFormField,
+    methods: { getValues, trigger },
+  } = context;
+  const values = getValues();
+  const errors = formFields
+    .filter(
+      (field) => !field.isHidden && !field.isParentHidden && !field.isDisabled && !field.meta.submission?.unspecified,
+    )
+    .flatMap((field) =>
+      field.validators?.flatMap((validatorConfig) => {
+        const validator = formFieldValidators[validatorConfig.type];
+        if (validator) {
+          const validationResults = validator.validate(field, values[field.id], {
+            formFields,
+            values,
+            expressionContext: {
+              patient,
+              mode: sessionMode,
+            },
+            ...validatorConfig,
+          });
+          const errors = validationResults.filter((result) => result.resultType === 'error');
+          if (errors.length) {
+            field.meta.submission = { ...field.meta.submission, errors };
+            updateFormField(field);
+            addInvalidField(field);
+          }
+          return errors;
+        }
+      }),
+    )
+    .filter((error) => Boolean(error));
+  return errors.length === 0;
+}
+
+export async function processPostSubmissionActions(
+  postSubmissionHandlers: PostSubmissionActionMeta[],
+  submissionResults: OpenmrsResource[],
+  patient: fhir.Patient,
+  sessionMode: SessionMode,
+  t: TFunction,
+) {
+  return Promise.all(
+    postSubmissionHandlers.map(async ({ postAction, config, actionId, enabled }) => {
+      try {
+        const encounterData = [];
+        if (submissionResults) {
+          submissionResults.forEach((result) => {
+            if (result?.data) {
+              encounterData.push(result.data);
+            }
+            if (result?.uuid) {
+              encounterData.push(result);
+            }
+          });
+
+          if (encounterData.length) {
+            const isActionEnabled = enabled ? evaluatePostSubmissionExpression(enabled, encounterData) : true;
+            if (isActionEnabled) {
+              await postAction.applyAction(
+                {
+                  patient,
+                  sessionMode,
+                  encounters: encounterData,
+                },
+                config,
+              );
+            }
+          } else {
+            throw new Error('No encounter data to process post submission action');
+          }
+        } else {
+          throw new Error('No handlers available to process post submission action');
+        }
+      } catch (error) {
+        const errorMessages = extractErrorMessagesFromResponse(error);
+        showSnackbar({
+          title: String(
+            t(
+              'errorDescriptionTitle',
+              actionId ? actionId.replace(/([a-z])([A-Z])/g, '$1 $2') : 'Post Submission Error',
+            ),
+          ),
+          subtitle: String(t('errorDescription', '{{errors}}', { errors: errorMessages.join(', ') })),
+          kind: 'error',
+          isLowContrast: false,
+        });
+      }
+    }),
+  );
+}