openchs-models 1.32.41 → 1.32.42

package/dist/Media.js

@@ -11,6 +11,82 @@ var _Concept = _interopRequireDefault(require("./Concept"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const findMediaObservations = (...observations) => _lodash.default.filter(_lodash.default.flatten(observations), observation => _Concept.default.dataType.Media.includes(observation.concept.datatype));
+// Helper to check if an observation is a media observation
+const isMediaObservation = observation => {
+  if (!observation || !observation.concept) return false;
+  return _Concept.default.dataType.Media.includes(observation.concept.datatype);
+}; // Helper to collect media observations from an array of observations
+
+
+const collectMediaObservations = observations => {
+  return _lodash.default.filter(observations, isMediaObservation);
+}; // Helper to process observations in a question group
+
+
+const processQuestionGroup = questionGroup => {
+  // Get observations inside the question group
+  const groupObservations = questionGroup.getValue && Array.isArray(questionGroup.getValue()) ? questionGroup.getValue() : []; // Return media observations inside the question group
+
+  return collectMediaObservations(groupObservations);
+}; // Helper to process observations in a repeatable question group
+
+
+const processRepeatableQuestionGroup = repeatableQuestionGroup => {
+  // Get all question groups from the repeatable question group
+  const allGroups = repeatableQuestionGroup.getAllQuestionGroupObservations && repeatableQuestionGroup.getAllQuestionGroupObservations() || []; // Process each question group and collect all media observations
+
+  return _lodash.default.flatten(allGroups.map(group => processQuestionGroup(group)));
+}; // Process an individual observation and its nested structure if applicable
+
+
+const processObservation = observation => {
+  if (!observation) return [];
+  const result = []; // Case 1: Direct media observation
+
+  if (isMediaObservation(observation)) {
+    result.push(observation);
+  } // Check for nested observations in value wrapper
+
+
+  try {
+    const valueWrapper = observation.getValueWrapper && observation.getValueWrapper();
+
+    if (!valueWrapper) {
+      return result;
+    } // Case 2a: Regular Question Group
+
+
+    if (!valueWrapper.isRepeatable || !valueWrapper.isRepeatable()) {
+      result.push(...processQuestionGroup(valueWrapper));
+    } // Case 2b: Repeatable Question Group
+    else {
+        result.push(...processRepeatableQuestionGroup(valueWrapper));
+      }
+  } catch (error) {
+    // Silently handle parsing errors or invalid structures
+    console.log(`[INFO] Error processing observation: ${error.message}`);
+  }
+
+  return result;
+}; // Main function to find all media observations
+
+
+const findMediaObservations = (...observations) => {
+  console.log(`[INFO] Finding media observations in ${observations.length} observation arrays`); // Handle null or undefined input
+
+  if (!observations || !observations.length) return []; // Filter out null or undefined values
+
+  const validObservations = observations.filter(obs => obs != null); // Process all input observation arrays
+
+  const flattenedObservations = _lodash.default.flatten(validObservations); // Handle empty array
+
+
+  if (!flattenedObservations || !flattenedObservations.length) return []; // Process each observation and collect results
+
+  const result = _lodash.default.flatten(flattenedObservations.map(processObservation).filter(item => item != null));
+
+  console.log(`[INFO] Found ${result.length} media observations`);
+  return result;
+};
 
 exports.findMediaObservations = findMediaObservations;

package/dist/ObservationsHolder.js

@@ -43,6 +43,49 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+// Helper function to find media observation by value
+const findMediaObservationByValue = (observations, targetValue) => {
+  if (!observations || !Array.isArray(observations)) return null;
+  return _lodash.default.find(observations, obs => {
+    // Check direct value
+    if (obs.getValue && obs.getValue() === targetValue) return true; // Check coded values (for MultipleCodedValues)
+
+    const valueJSON = obs.valueJSON;
+
+    if (valueJSON && valueJSON.answer && Array.isArray(valueJSON.answer)) {
+      return valueJSON.answer.includes(targetValue);
+    }
+
+    return false;
+  });
+}; // Helper function to update media value
+
+
+const updateMediaValue = (mediaObs, oldVal, newVal) => {
+  if (!mediaObs) return false; // For coded values, we need to update the array content
+
+  if (mediaObs.valueJSON && mediaObs.valueJSON.answer && Array.isArray(mediaObs.valueJSON.answer)) {
+    const answerIndex = mediaObs.valueJSON.answer.indexOf(oldVal);
+
+    if (answerIndex >= 0) {
+      mediaObs.valueJSON.answer[answerIndex] = newVal;
+      return true;
+    }
+  } else {
+    // Regular value update
+    mediaObs.setValue(mediaObs.concept.getValueWrapperFor(newVal));
+    return true;
+  }
+
+  return false;
+}; // Process each question group observation
+
+
+const processQuestionGroupObservations = (observations, oldVal, newVal) => {
+  const mediaObs = findMediaObservationByValue(observations, oldVal);
+  return mediaObs ? updateMediaValue(mediaObs, oldVal, newVal) : false;
+};
+
 class ObservationsHolder {
   constructor(observations) {
     this.observations = observations;
@@ -472,50 +515,176 @@ class ObservationsHolder {
 
 
   updateObservationBasedOnValue(oldValue, newValue) {
+    // Try to find at top level first
     const observation = this.findObservationByValue(oldValue);
 
     if (observation) {
       observation.setValue(observation.concept.getValueWrapperFor(newValue));
-    }
-  }
+      return true;
+    } // Search in nested structures if not found at top level
 
-  replaceMediaObservation(oldValue, newValue, conceptUUID) {
-    if (_lodash.default.isNil(conceptUUID)) {
-      return this.updateObservationBasedOnValue(oldValue, newValue);
-    }
 
-    const observation = _lodash.default.find(this.observations, observation => observation.concept.uuid === conceptUUID);
+    let updated = false; // Iterate through all observations
 
-    if (observation) {
-      const valueWrapper = observation.getValueWrapper();
+    _lodash.default.forEach(this.observations, obs => {
+      // Skip non-question group observations
+      if (obs.concept.datatype !== _Concept.default.dataType.QuestionGroup) return;
+      const valueWrapper = obs.getValueWrapper && obs.getValueWrapper();
+      if (!valueWrapper) return; // Handle RepeatableQuestionGroup
+
+      if (valueWrapper.isRepeatable && valueWrapper.isRepeatable()) {
+        const allGroups = valueWrapper.getAllQuestionGroupObservations && valueWrapper.getAllQuestionGroupObservations();
 
-      if (observation.concept.datatype === _Concept.default.dataType.ImageV2) {
-        const mediaObjects = JSON.parse(valueWrapper.getValue());
+        if (allGroups && allGroups.length) {
+          // Check each group in the repeatable question group
+          allGroups.forEach(group => {
+            const groupObservations = group.getValue && group.getValue();
 
-        const newAnswers = _lodash.default.map(mediaObjects, mediaObject => {
-          if (mediaObject.uri === oldValue) {
-            mediaObject.uri = newValue;
+            if (processQuestionGroupObservations(groupObservations, oldValue, newValue)) {
+              updated = true;
+            }
+          });
+        }
+      } // Handle regular QuestionGroup
+      else {
+          const groupObservations = valueWrapper.getValue && valueWrapper.getValue();
+
+          if (processQuestionGroupObservations(groupObservations, oldValue, newValue)) {
+            updated = true;
           }
+        }
+    });
 
-          return mediaObject;
-        });
+    return updated;
+  } // Helper method to update media value in an observation
 
+
+  _updateMediaValueInObservation(observation, oldValue, newValue) {
+    if (!observation) return false;
+    const valueWrapper = observation.getValueWrapper && observation.getValueWrapper();
+    if (!valueWrapper) return false; // Handle ImageV2 type
+
+    if (observation.concept.datatype === _Concept.default.dataType.ImageV2) {
+      const mediaObjects = JSON.parse(valueWrapper.getValue());
+      let updated = false;
+
+      const newAnswers = _lodash.default.map(mediaObjects, mediaObject => {
+        if (mediaObject.uri === oldValue) {
+          mediaObject.uri = newValue;
+          updated = true;
+        }
+
+        return mediaObject;
+      });
+
+      if (updated) {
         observation.valueJSON = new _PrimitiveValue.default(JSON.stringify(newAnswers), _Concept.default.dataType.ImageV2);
-      } else if (valueWrapper.isMultipleCoded) {
+        return true;
+      }
+    } // Handle multiple coded values
+    else if (valueWrapper.isMultipleCoded) {
         const answers = valueWrapper.getValue();
 
         const oldValueIndex = _lodash.default.indexOf(answers, oldValue);
 
-        if (oldValueIndex < 0) return; // due to race condition the old value might have been removed
+        if (oldValueIndex >= 0) {
+          const newAnswers = _lodash.default.reject(answers, answer => answer === oldValue);
 
-        const newAnswers = _lodash.default.reject(answers, answer => answer === oldValue);
+          newAnswers.splice(oldValueIndex, 0, newValue);
+          observation.valueJSON = new _MultipleCodedValues.default(newAnswers);
+          return true;
+        }
+      } // Handle single coded value
+      else if (valueWrapper.getValue() === oldValue) {
+          observation.valueJSON = new _SingleCodedValue.default(newValue);
+          return true;
+        }
 
-        newAnswers.splice(oldValueIndex, 0, newValue);
-        observation.valueJSON = new _MultipleCodedValues.default(newAnswers);
-      } else {
-        observation.valueJSON = new _SingleCodedValue.default(newValue);
+    return false;
+  } // Helper to find and update media in question group
+
+
+  _updateMediaInQuestionGroup(questionGroup, conceptUUID, oldValue, newValue) {
+    if (!questionGroup || !questionGroup.getValue) return false;
+    const groupObservations = questionGroup.getValue();
+    if (!groupObservations || !Array.isArray(groupObservations)) return false; // Find media observation either by concept UUID or by value
+
+    const mediaObs = _lodash.default.find(groupObservations, obs => obs.concept.uuid === conceptUUID || _Concept.default.dataType.Media.includes(obs.concept.datatype) && obs.getValue && obs.getValue() === oldValue); // Update if found
+
+
+    return this._updateMediaValueInObservation(mediaObs, oldValue, newValue);
+  } // Helper to find and update media in repeatable question group
+
+
+  _updateMediaInRepeatableQuestionGroup(repeatableGroup, conceptUUID, oldValue, newValue) {
+    if (!repeatableGroup || !repeatableGroup.getAllQuestionGroupObservations) return false;
+    const allGroups = repeatableGroup.getAllQuestionGroupObservations();
+    if (!allGroups || !allGroups.length) return false; // Check each group in the repeatable question group
+
+    let updated = false;
+    allGroups.forEach(group => {
+      if (this._updateMediaInQuestionGroup(group, conceptUUID, oldValue, newValue)) {
+        updated = true;
       }
-    }
+    });
+    return updated;
+  } // Helper to process a question group (regular or repeatable) and update media within it
+
+
+  _processQuestionGroupWrapper(wrapper, conceptUUID, oldValue, newValue, sourceName) {
+    if (!wrapper) return false; // Determine if it's a repeatable question group or regular question group
+
+    const isRepeatable = wrapper.isRepeatable && wrapper.isRepeatable(); // Process the appropriate group type
+
+    return isRepeatable ? this._updateMediaInRepeatableQuestionGroup(wrapper, conceptUUID, oldValue, newValue) : this._updateMediaInQuestionGroup(wrapper, conceptUUID, oldValue, newValue);
+  }
+
+  replaceMediaObservation(oldValue, newValue, conceptUUID) {
+    console.log(`[INFO] Replacing media: ${oldValue} → ${newValue}`); // Since conceptUUID is always provided in practice, optimize for that case first
+    // Try to find direct top-level observation with matching concept UUID
+
+    const directObservation = _lodash.default.find(this.observations, obs => obs.concept.uuid === conceptUUID);
+
+    if (directObservation) {
+      // Direct media observation
+      if (_Concept.default.dataType.Media.includes(directObservation.concept.datatype)) {
+        if (this._updateMediaValueInObservation(directObservation, oldValue, newValue)) {
+          console.log(`[INFO] Updated media in direct observation`);
+          return true;
+        }
+      } // Question Group containing the media
+      else if (directObservation.concept.datatype === _Concept.default.dataType.QuestionGroup) {
+          const valueWrapper = directObservation.getValueWrapper();
+
+          if (this._processQuestionGroupWrapper(valueWrapper, conceptUUID, oldValue, newValue)) {
+            console.log(`[INFO] Updated media in question group`);
+            return true;
+          }
+        }
+    } // Check nested structures (this works both with and without conceptUUID)
+
+
+    let updated = false;
+
+    _lodash.default.forEach(this.observations, obs => {
+      // Only process question groups
+      if (obs.concept.datatype !== _Concept.default.dataType.QuestionGroup) return;
+      const valueWrapper = obs.getValueWrapper && obs.getValueWrapper();
+      if (!valueWrapper) return;
+
+      if (this._processQuestionGroupWrapper(valueWrapper, conceptUUID, oldValue, newValue)) {
+        updated = true;
+      }
+    });
+
+    if (updated) {
+      console.log(`[INFO] Updated media in nested structure`);
+      return true;
+    } // As a fallback, use value-based replacement if we couldn't find it by concept
+    // This ensures backward compatibility and handles edge cases
+
+
+    return this.updateObservationBasedOnValue(oldValue, newValue);
   }
 
   toString(I18n) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "openchs-models",
     "description": "OpenCHS data model to be used by front end clients",
-    "version": "1.32.41",
+    "version": "1.32.42",
     "private": false,
     "repository": {
         "type": "git",