@olaboot/esm-form-engine-lib 4.1.0

package/dist/adapters/obs-adapter.js

@@ -0,0 +1,284 @@
+import dayjs from "dayjs";
+import { ConceptTrue, codedTypes } from "../constants.js";
+import { hasRendering, gracefullySetSubmission, clearSubmission, flattenObsList, parseToLocalDateTime, formatDateAsDisplayString } from "../utils/common-utils.js";
+import { isEmpty } from "../validators/form-validator.js";
+import { attachmentUrl, getAttachmentByUuid } from "@openmrs/esm-framework";
+// Temporarily holds observations that have already been bound with matching fields
+export let assignedObsIds = [];
+export const ObsAdapter = {
+    async getInitialValue (field, sourceObject, context) {
+        const encounter = sourceObject ?? context.domainObjectValue;
+        const matchingObs = findObsByFormField(flattenObsList(encounter.obs), assignedObsIds, field);
+        if (hasRendering(field, 'file') && matchingObs?.length) {
+            return resolveAttachmentsFromObs(field, matchingObs);
+        }
+        return extractFieldValue(field, matchingObs, true);
+    },
+    async getPreviousValue (field, sourceObject, context) {
+        const encounter = sourceObject ?? context.previousDomainObjectValue;
+        if (encounter) {
+            const value = extractFieldValue(field, findObsByFormField(flattenObsList(encounter.obs), assignedObsIds, field), true);
+            if (!isEmpty(value)) {
+                return {
+                    value,
+                    display: this.getDisplayValue(field, value)
+                };
+            }
+        }
+        return null;
+    },
+    getDisplayValue: (field, value)=>{
+        const rendering = field.questionOptions.rendering;
+        if (isEmpty(value)) {
+            return value;
+        }
+        if (value instanceof Date) {
+            return formatDateAsDisplayString(field, value);
+        }
+        if (rendering === 'checkbox') {
+            return value.map((selected)=>field.questionOptions.answers?.find((option)=>option.concept == selected)?.label);
+        }
+        if (rendering === 'toggle') {
+            return value ? field.questionOptions.toggleOptions.labelTrue : field.questionOptions.toggleOptions.labelFalse;
+        }
+        if (codedTypes.includes(rendering)) {
+            return field.questionOptions.answers?.find((option)=>option.concept == value)?.label;
+        }
+        return value;
+    },
+    transformFieldValue: (field, value, context)=>{
+        // clear previous submission
+        clearSubmission(field);
+        if (!field.meta.initialValue?.omrsObject && isEmpty(value)) {
+            return null;
+        }
+        if (hasRendering(field, 'checkbox')) {
+            return handleMultiSelect(field, Array.isArray(value) ? value : [
+                value
+            ]);
+        }
+        if (hasRendering(field, 'file')) {
+            return handleAttachments(field, value);
+        }
+        if (!isEmpty(value) && hasPreviousObsValueChanged(field, value)) {
+            return gracefullySetSubmission(field, editObs(field, value), undefined);
+        }
+        if (field.meta.initialValue?.omrsObject && isEmpty(value)) {
+            return gracefullySetSubmission(field, undefined, voidObs(field.meta.initialValue.omrsObject));
+        }
+        if (!isEmpty(value)) {
+            return gracefullySetSubmission(field, constructObs(field, value), undefined);
+        }
+        return null;
+    },
+    tearDown: function() {
+        assignedObsIds = [];
+    }
+};
+// Helpers
+/**
+ * Extracts field's primitive value from obs
+ */ function extractFieldValue(field, obsList = [], makeFieldDirty = false) {
+    const rendering = field.questionOptions.rendering;
+    if (!field.meta) {
+        field.meta = {
+            initialValue: {
+                omrsObject: null,
+                refinedValue: null
+            }
+        };
+    }
+    if (obsList.length) {
+        if (rendering == 'checkbox') {
+            assignedObsIds.push(...obsList.map((obs)=>obs.uuid));
+            field.meta.initialValue.omrsObject = makeFieldDirty ? obsList : null;
+            return obsList.map((o)=>o.value.uuid);
+        }
+        const obs = obsList[0];
+        if (makeFieldDirty) {
+            field.meta.initialValue.omrsObject = {
+                ...obs
+            };
+        }
+        assignedObsIds.push(obs.uuid);
+        if (typeof obs.value === 'string' || typeof obs.value === 'number') {
+            if (rendering.startsWith('date')) {
+                const dateObject = parseToLocalDateTime(obs.value);
+                if (makeFieldDirty) {
+                    const obsObject = field.meta.initialValue.omrsObject;
+                    obsObject.value = dayjs(dateObject).format('YYYY-MM-DD HH:mm');
+                }
+                return dateObject;
+            }
+            return obs.value;
+        }
+        if (rendering == 'toggle') {
+            return obs.value.uuid === ConceptTrue;
+        }
+        if (rendering == 'fixed-value') {
+            return field['fixedValue'];
+        }
+        return obs.value?.uuid;
+    }
+    return '';
+}
+export function constructObs(field, value) {
+    if (isEmpty(value) && field.type !== 'obsGroup') {
+        return null;
+    }
+    const draftObs = field.type === 'obsGroup' ? {
+        groupMembers: []
+    } : {
+        value: field.questionOptions.rendering.startsWith('date') ? formatDateByPickerType(field, value) : value
+    };
+    return {
+        ...draftObs,
+        concept: field.questionOptions.concept,
+        formFieldNamespace: 'rfe-forms',
+        formFieldPath: `rfe-forms-${field.id}`
+    };
+}
+export function voidObs(obs) {
+    return {
+        uuid: obs.uuid,
+        voided: true
+    };
+}
+export function editObs(field, newValue) {
+    const oldObs = field.meta.initialValue?.omrsObject;
+    const formattedValue = field.questionOptions.rendering.startsWith('date') ? formatDateByPickerType(field, newValue) : newValue;
+    return {
+        uuid: oldObs.uuid,
+        value: formattedValue,
+        formFieldNamespace: 'rfe-forms',
+        formFieldPath: `rfe-forms-${field.id}`
+    };
+}
+function formatDateByPickerType(field, value) {
+    if (field.datePickerFormat) {
+        switch(field.datePickerFormat){
+            case 'calendar':
+                return dayjs(value).format('YYYY-MM-DD');
+            case 'timer':
+                return dayjs(value).format('HH:mm');
+            case 'both':
+                return dayjs(value).format('YYYY-MM-DD HH:mm');
+            default:
+                return dayjs(value).format('YYYY-MM-DD');
+        }
+    }
+    return value;
+}
+export function hasPreviousObsValueChanged(field, newValue) {
+    const previousObs = field.meta.initialValue?.omrsObject;
+    if (isEmpty(previousObs)) {
+        return false;
+    }
+    if (codedTypes.includes(field.questionOptions.rendering)) {
+        return previousObs.value.uuid !== newValue;
+    }
+    if (hasRendering(field, 'date')) {
+        return dayjs(newValue).diff(dayjs(previousObs.value), 'D') !== 0;
+    }
+    if (hasRendering(field, 'datetime') || field.datePickerFormat === 'both') {
+        return dayjs(newValue).diff(dayjs(previousObs.value), 'minute') !== 0;
+    }
+    if (hasRendering(field, 'toggle')) {
+        return previousObs.value.uuid === ConceptTrue !== newValue;
+    }
+    return previousObs.value !== newValue;
+}
+function handleMultiSelect(field, values = []) {
+    // three possible scenarios
+    // 1. we have a previous value and an empty current value
+    // 2. a mix of both (previous and current)
+    // 3. we only have a current value
+    const obsArray = field.meta.initialValue?.omrsObject;
+    if (obsArray?.length && isEmpty(values)) {
+        // we assume the user cleared the existing value(s)
+        // so we void all previous values
+        return gracefullySetSubmission(field, null, obsArray.map((previousValue)=>voidObs(previousValue)));
+    }
+    if (obsArray?.length && !isEmpty(values)) {
+        const toBeVoided = obsArray.filter((obs)=>!values.includes(obs.value.uuid));
+        const toBeCreated = values.filter((v)=>!obsArray.some((obs)=>obs.value.uuid === v));
+        return gracefullySetSubmission(field, toBeCreated.map((value)=>constructObs(field, value)), toBeVoided.map((obs)=>voidObs(obs)));
+    }
+    return gracefullySetSubmission(field, values.map((value)=>constructObs(field, value)), undefined);
+}
+function handleAttachments(field, attachments = []) {
+    const voided = attachments.filter((attachment)=>attachment.uuid && attachment.voided).map((voided)=>({
+            uuid: voided.uuid,
+            voided: true
+        }));
+    const newAttachments = field.meta.submission.newValue = attachments.filter((attachment)=>!attachment.uuid).map((newAttachment)=>({
+            formFieldNamespace: 'rfe-forms',
+            formFieldPath: `rfe-forms-${field.id}`,
+            ...newAttachment
+        }));
+    return gracefullySetSubmission(field, newAttachments, voided);
+}
+/**
+ * Retrieves a list of observations from a given `obsList` that correspond to the specified field.
+ *
+ * Notes:
+ * If the query by field-path returns an empty list, the function falls back to querying
+ * by concept and uses `claimedObsIds` to exclude already assigned observations.
+ *
+ * When the field belongs to an obsGroup (i.e. `field.meta.groupId` is set), the concept
+ * fallback is scoped to observations that are members of the matching parent obsGroup.
+ * This prevents child obs from one obsGroup from being incorrectly assigned to fields
+ * in a different obsGroup that happens to share the same concept.
+ */ export function findObsByFormField(obsList, claimedObsIds, field) {
+    const obs = obsList.filter((candidate)=>{
+        // we ignore the concept for attachments because they're managed from the backend
+        if (hasRendering(field, 'file') && candidate.formFieldPath == `rfe-forms-${field.id}`) {
+            return true;
+        }
+        return candidate.formFieldPath == `rfe-forms-${field.id}` && candidate.concept.uuid == field.questionOptions.concept;
+    });
+    // We shall fall back to mapping by the associated concept
+    // That being said, we shall find all matching obs and pick the one that wasn't previously claimed.
+    if (!obs?.length) {
+        let obsByConcept = obsList.filter((obs)=>obs.concept.uuid == field.questionOptions.concept);
+        // If this field belongs to an obsGroup, restrict the concept fallback to
+        // respect obsGroup boundaries.  For each candidate obs we check whether it
+        // is a member of any obsGroup in the encounter.  Three cases:
+        //   1. The obs is standalone (not in any group) → allow (normal fallback).
+        //   2. The obs is in a group whose formFieldPath matches the expected
+        //      parent → allow (correct group).
+        //   3. The obs is in a group with a *different* formFieldPath → exclude
+        //      (prevents cross-group concept bleeding, e.g. PrEP → ARV).
+        //   4. The obs is in a group that has no formFieldPath (old encounter) →
+        //      allow (backward compatibility).
+        if (field.meta?.groupId) {
+            const parentPath = `rfe-forms-${field.meta.groupId}`;
+            obsByConcept = obsByConcept.filter((candidate)=>{
+                // Find the obsGroup that owns this candidate (if any)
+                const ownerGroup = obsList.find((o)=>o.groupMembers?.some((m)=>m.uuid === candidate.uuid));
+                if (!ownerGroup) return true; // case 1: standalone
+                if (!ownerGroup.formFieldPath) return true; // case 4: old encounter
+                return ownerGroup.formFieldPath == parentPath; // case 2 or 3
+            });
+        }
+        return claimedObsIds?.length ? obsByConcept.filter((obs)=>!claimedObsIds.includes(obs.uuid)) : obsByConcept;
+    }
+    return obs;
+}
+async function resolveAttachmentsFromObs(field, obs) {
+    const abortController = new AbortController();
+    const attachments = await Promise.all(obs.map((obs)=>getAttachmentByUuid(obs.uuid, abortController).then((response)=>response.data).catch((error)=>{
+            console.error(`Failed to fetch attachment ${obs.uuid}:`, error);
+            return null;
+        })));
+    field.meta.initialValue = {
+        omrsObject: obs
+    };
+    return attachments.filter(Boolean).map((attachment)=>({
+            uuid: attachment.uuid,
+            base64Content: `${window.openmrsBase}${attachmentUrl}/${attachment.uuid}/bytes`,
+            fileName: attachment.filename,
+            fileDescription: attachment.comment,
+            fileType: attachment.bytesContentFamily?.toLowerCase()
+        }));
+}