openchs-models 1.9.2 → 1.10.0

package/dist/AbstractEncounter.js

@@ -113,30 +113,30 @@ class AbstractEncounter extends _BaseEntity.default {
     };
   }
 
-  findObservation(conceptName) {
+  findObservation(conceptNameOrUuid) {
     return _lodash.default.find(this.observations, observation => {
-      return observation.concept.name === conceptName;
+      return observation.concept.name === conceptNameOrUuid || observation.concept.uuid === conceptNameOrUuid;
     });
   }
 
-  findCancelEncounterObservation(conceptName) {
+  findCancelEncounterObservation(conceptNameOrUuid) {
     return _lodash.default.find(this.cancelObservations, observation => {
-      return observation.concept.name === conceptName;
+      return observation.concept.name === conceptNameOrUuid || observation.concept.uuid === conceptNameOrUuid;
     });
   }
 
-  findCancelEncounterObservationReadableValue(conceptName) {
-    const observationForConcept = this.findCancelEncounterObservation(conceptName);
+  findCancelEncounterObservationReadableValue(conceptNameOrUuid) {
+    const observationForConcept = this.findCancelEncounterObservation(conceptNameOrUuid);
     return _lodash.default.isEmpty(observationForConcept) ? observationForConcept : observationForConcept.getReadableValue();
   }
 
-  getObservationValue(conceptName) {
-    const observationForConcept = this.findObservation(conceptName);
+  getObservationValue(conceptNameOrUuid) {
+    const observationForConcept = this.findObservation(conceptNameOrUuid);
     return _lodash.default.isEmpty(observationForConcept) ? observationForConcept : observationForConcept.getValue();
   }
 
-  getObservationReadableValue(conceptName) {
-    const observationForConcept = this.findObservation(conceptName);
+  getObservationReadableValue(conceptNameOrUuid) {
+    const observationForConcept = this.findObservation(conceptNameOrUuid);
     return _lodash.default.isEmpty(observationForConcept) ? observationForConcept : observationForConcept.getReadableValue();
   }
 
@@ -171,8 +171,8 @@ class AbstractEncounter extends _BaseEntity.default {
     return _lodash.default.isNil(this.encounterDateTime) && _lodash.default.isNil(this.cancelDateTime);
   }
 
-  hasObservation(conceptName) {
-    return !_lodash.default.isNil(this.getObservationValue(conceptName));
+  hasObservation(conceptNameOrUuid) {
+    return !_lodash.default.isNil(this.getObservationValue(conceptNameOrUuid));
   }
 
   findMediaObservations() {

package/dist/ChecklistItem.js

@@ -208,9 +208,9 @@ class ChecklistItem {
     return `ChecklistItem{uuid=${this.uuid}}`;
   }
 
-  findObservation(conceptName) {
+  findObservation(conceptNameOrUuid) {
     return _lodash.default.find(this.observations, observation => {
-      return observation.concept.name === conceptName;
+      return observation.concept.name === conceptNameOrUuid || observation.concept.uuid === conceptNameOrUuid;
     });
   }
 

package/dist/Concept.js

@@ -182,8 +182,8 @@ class Concept {
     return conceptAnswer;
   }
 
-  getPossibleAnswerConcept(name) {
-    return _lodash.default.find(this.answers, conceptAnswer => conceptAnswer.concept.name === name);
+  getPossibleAnswerConcept(nameOrUuid) {
+    return _lodash.default.find(this.answers, conceptAnswer => conceptAnswer.concept.name === nameOrUuid || conceptAnswer.concept.uuid === nameOrUuid);
   }
 
   getValueWrapperFor(obsValue) {
@@ -240,6 +240,10 @@ class Concept {
     return _lodash.default.find(this.getAnswers(), answer => answer.concept.name === answerName);
   }
 
+  getAnswerWithConceptUuid(answerConceptUuid) {
+    return _lodash.default.find(this.getAnswers(), answer => answer.concept.uuid === answerConceptUuid);
+  }
+
   get translatedFieldValue() {
     return this.name;
   }

package/dist/Family.js

@@ -131,14 +131,14 @@ class Family extends _BaseEntity.default {
     return family;
   }
 
-  findObservation(conceptName) {
+  findObservation(conceptNameOrUuid) {
     return _lodash.default.find(this.observations, observation => {
-      return observation.concept.name === conceptName;
+      return observation.concept.name === conceptNameOrUuid || observation.concept.uuid === conceptNameOrUuid;
     });
   }
 
-  getObservationValue(conceptName) {
-    const observationForConcept = this.findObservation(conceptName);
+  getObservationValue(conceptNameOrUuid) {
+    const observationForConcept = this.findObservation(conceptNameOrUuid);
     return _lodash.default.isEmpty(observationForConcept) ? observationForConcept : observationForConcept.getValue();
   }
 

package/dist/Individual.js

@@ -146,12 +146,12 @@ class Individual extends _BaseEntity.default {
     return resource;
   }
 
-  findObservationAcrossAllEnrolments(conceptName) {
-    return this.nonVoidedEnrolments().find(enrolment => enrolment.findLatestObservationInEntireEnrolment(conceptName) !== undefined);
+  findObservationAcrossAllEnrolments(conceptNameOrUuid) {
+    return this.nonVoidedEnrolments().find(enrolment => enrolment.findLatestObservationInEntireEnrolment(conceptNameOrUuid) !== undefined);
   }
 
-  observationExistsAcrossAllEnrolments(conceptName) {
-    return this.nonVoidedEnrolments().find(enrolment => enrolment.findLatestObservationInEntireEnrolment(conceptName) !== undefined);
+  observationExistsAcrossAllEnrolments(conceptNameOrUuid) {
+    return this.nonVoidedEnrolments().find(enrolment => enrolment.findLatestObservationInEntireEnrolment(conceptNameOrUuid) !== undefined);
   }
 
   static newInstance(uuid, firstName, lastName, dateOfBirth, dateOfBirthVerified, gender, lowestAddressLevel, subjectType) {
@@ -544,14 +544,14 @@ class Individual extends _BaseEntity.default {
     }
   }
 
-  findObservation(conceptName) {
+  findObservation(conceptNameOrUuid) {
     return _lodash.default.find(this.observations, observation => {
-      return observation.concept.name === conceptName;
+      return observation.concept.name === conceptNameOrUuid || observation.concept.uuid === conceptNameOrUuid;
     });
   }
 
-  getObservationValue(conceptName) {
-    const observationForConcept = this.findObservation(conceptName);
+  getObservationValue(conceptNameOrUuid) {
+    const observationForConcept = this.findObservation(conceptNameOrUuid);
     return _lodash.default.isEmpty(observationForConcept) ? observationForConcept : observationForConcept.getValue();
   }
 
@@ -681,13 +681,13 @@ class Individual extends _BaseEntity.default {
     return _lodash.default.chain(this.getEncounters(false)).filter(enc => enc.encounterDateTime).filter(enc => enc.encounterDateTime < currentEncounter.encounterDateTime).filter(enc => encounterTypes.some(encounterType => encounterType === enc.encounterType.name)).nth(n).value();
   }
 
-  _findObservationWithDateFromAllEncounters(conceptName, encounters) {
+  _findObservationWithDateFromAllEncounters(conceptNameOrUuid, encounters) {
     let observation;
     let encounter;
 
     for (let i = 0; i < encounters.length; i++) {
       encounter = encounters[i];
-      observation = encounters[i].findObservation(conceptName);
+      observation = encounters[i].findObservation(conceptNameOrUuid);
       if (!_lodash.default.isNil(observation)) return {
         observation: observation,
         date: encounter.encounterDateTime
@@ -697,22 +697,22 @@ class Individual extends _BaseEntity.default {
     return {};
   }
 
-  _findObservationFromAllEncounters(conceptName, encounters) {
-    return this._findObservationWithDateFromAllEncounters(conceptName, encounters).observation;
+  _findObservationFromAllEncounters(conceptNameOrUuid, encounters) {
+    return this._findObservationWithDateFromAllEncounters(conceptNameOrUuid, encounters).observation;
   }
 
-  findLatestObservationFromPreviousEncounters(conceptName, currentEncounter) {
+  findLatestObservationFromPreviousEncounters(conceptNameOrUuid, currentEncounter) {
     const encounters = _lodash.default.chain(this.getEncounters(false)).filter(enc => enc.encounterDateTime).filter(enc => enc.encounterDateTime < currentEncounter.encounterDateTime).value();
 
-    return this._findObservationFromAllEncounters(conceptName, encounters);
+    return this._findObservationFromAllEncounters(conceptNameOrUuid, encounters);
   }
 
-  findLatestObservationFromEncounters(conceptName, currentEncounter) {
+  findLatestObservationFromEncounters(conceptNameOrUuid, currentEncounter) {
     const previousEncounters = _lodash.default.chain(this.getEncounters(false)).filter(enc => enc.encounterDateTime).filter(enc => currentEncounter ? enc.encounterDateTime < currentEncounter.encounterDateTime : true).value();
 
     const encounters = _lodash.default.chain(currentEncounter).concat(previousEncounters).compact().value();
 
-    return this._findObservationFromAllEncounters(conceptName, encounters);
+    return this._findObservationFromAllEncounters(conceptNameOrUuid, encounters);
   }
 
   scheduledEncountersOfType(encounterTypeName) {
@@ -746,8 +746,8 @@ class Individual extends _BaseEntity.default {
     }
   }
 
-  getObservationReadableValue(conceptName) {
-    const observationForConcept = this.findObservation(conceptName);
+  getObservationReadableValue(conceptNameOrUuid) {
+    const observationForConcept = this.findObservation(conceptNameOrUuid);
     return _lodash.default.isEmpty(observationForConcept) ? observationForConcept : observationForConcept.getReadableValue();
   }
 

package/dist/ProgramEncounter.js

@@ -68,16 +68,16 @@ class ProgramEncounter extends _AbstractEncounter.default {
     return "ProgramEncounter";
   }
 
-  findObservationInEntireEnrolment(conceptName) {
-    return this.programEnrolment.findObservationInEntireEnrolment(conceptName);
+  findObservationInEntireEnrolment(conceptNameOrUuid) {
+    return this.programEnrolment.findObservationInEntireEnrolment(conceptNameOrUuid);
   }
 
-  findLatestObservationInEntireEnrolment(conceptName, currentEncounter) {
-    return this.programEnrolment.findLatestObservationInEntireEnrolment(conceptName, currentEncounter);
+  findLatestObservationInEntireEnrolment(conceptNameOrUuid, currentEncounter) {
+    return this.programEnrolment.findLatestObservationInEntireEnrolment(conceptNameOrUuid, currentEncounter);
   }
 
-  observationExistsInEntireEnrolment(conceptName) {
-    return !_lodash.default.isNil(this.programEnrolment.findObservationInEntireEnrolment(conceptName));
+  observationExistsInEntireEnrolment(conceptNameOrUuid) {
+    return !_lodash.default.isNil(this.programEnrolment.findObservationInEntireEnrolment(conceptNameOrUuid));
   }
 
   get individual() {

package/dist/ProgramEnrolment.js

@@ -181,11 +181,11 @@ class ProgramEnrolment extends _BaseEntity.default {
     return _lodash.default.chain(this.nonVoidedEncounters()).filter(encounter => _lodash.default.isEmpty(encounterTypeNames) ? encounter : _lodash.default.some(encounterTypeNames, name => name === _lodash.default.get(encounter, "encounterType.name"))).filter(encounter => encounter.encounterDateTime).maxBy(encounter => encounter.encounterDateTime).value();
   }
 
-  getObservationsForConceptName(conceptName) {
+  getObservationsForConceptName(conceptNameOrUuid) {
     return _lodash.default.chain(this.getEncounters(true)).map(encounter => {
       return {
         encounterDateTime: encounter.encounterDateTime,
-        obs: encounter.findObservation(conceptName)
+        obs: encounter.findObservation(conceptNameOrUuid)
       };
     }).filter(observation => observation.obs).map(observation => {
       return {
@@ -227,14 +227,14 @@ class ProgramEnrolment extends _BaseEntity.default {
     return _lodash.default.uniqBy(_lodash.default.map(this.encounters, enc => enc.encounterType), "uuid");
   }
 
-  findObservationValueInEntireEnrolment(conceptName, checkInEnrolment) {
+  findObservationValueInEntireEnrolment(conceptNameOrUuid, checkInEnrolment) {
     let encounters = _lodash.default.reverse(this.getEncounters(true));
 
-    let observationWithDate = this._findObservationWithDateFromEntireEnrolment(conceptName, encounters, checkInEnrolment);
+    let observationWithDate = this._findObservationWithDateFromEntireEnrolment(conceptNameOrUuid, encounters, checkInEnrolment);
 
     if (_lodash.default.isNil(observationWithDate.observation)) {
       observationWithDate = {
-        observation: this.findObservation(conceptName),
+        observation: this.findObservation(conceptNameOrUuid),
         date: this.enrolmentDateTime
       };
     }
@@ -245,55 +245,55 @@ class ProgramEnrolment extends _BaseEntity.default {
     };
   }
 
-  findObservationInEntireEnrolment(conceptName, currentEncounter, latest = false) {
+  findObservationInEntireEnrolment(conceptNameOrUuid, currentEncounter, latest = false) {
     let encounters = _lodash.default.chain(this.getEncounters()).filter(enc => currentEncounter ? enc.uuid !== currentEncounter.uuid : true).concat(currentEncounter).compact().sortBy(enc => enc.encounterDateTime).value();
 
     encounters = latest ? _lodash.default.reverse(encounters) : encounters;
-    return this._findObservationFromEntireEnrolment(conceptName, encounters, true);
+    return this._findObservationFromEntireEnrolment(conceptNameOrUuid, encounters, true);
   }
 
-  observationExistsInEntireEnrolment(conceptName, currentEncounter) {
-    return !_lodash.default.isEmpty(this.findObservationInEntireEnrolment(conceptName, currentEncounter));
+  observationExistsInEntireEnrolment(conceptNameOrUuid, currentEncounter) {
+    return !_lodash.default.isEmpty(this.findObservationInEntireEnrolment(conceptNameOrUuid, currentEncounter));
   }
 
-  findLatestObservationInEntireEnrolment(conceptName, currentEncounter) {
-    return this.findObservationInEntireEnrolment(conceptName, currentEncounter, true);
+  findLatestObservationInEntireEnrolment(conceptNameOrUuid, currentEncounter) {
+    return this.findObservationInEntireEnrolment(conceptNameOrUuid, currentEncounter, true);
   }
 
-  findLatestObservationFromEncounters(conceptName, currentEncounter, checkInEnrolment = false) {
+  findLatestObservationFromEncounters(conceptNameOrUuid, currentEncounter, checkInEnrolment = false) {
     const encountersFromEnrolment = _lodash.default.chain(this.getEncounters()).filter(enc => enc.encounterDateTime).filter(enc => currentEncounter ? enc.encounterDateTime < currentEncounter.encounterDateTime : true).value();
 
     const encounters = _lodash.default.chain(currentEncounter).concat(encountersFromEnrolment).compact().value();
 
-    return this._findObservationFromEntireEnrolment(conceptName, encounters, checkInEnrolment);
+    return this._findObservationFromEntireEnrolment(conceptNameOrUuid, encounters, checkInEnrolment);
   }
 
-  findLatestObservationFromPreviousEncounters(conceptName, currentEncounter) {
+  findLatestObservationFromPreviousEncounters(conceptNameOrUuid, currentEncounter) {
     const encounters = _lodash.default.chain(this.getEncounters()).filter(enc => enc.encounterDateTime).filter(enc => enc.encounterDateTime < currentEncounter.encounterDateTime).value();
 
-    return this._findObservationFromEntireEnrolment(conceptName, encounters, false);
+    return this._findObservationFromEntireEnrolment(conceptNameOrUuid, encounters, false);
   }
 
-  findLatestPreviousEncounterWithValueForConcept(currentEncounter, conceptName, valueConceptName) {
+  findLatestPreviousEncounterWithValueForConcept(currentEncounter, conceptNameOrUuid, valueConceptName) {
     const encounters = _lodash.default.chain(this.getEncounters()).filter(enc => enc.encounterDateTime).filter(enc => enc.encounterDateTime < currentEncounter.encounterDateTime).value();
 
     for (let i = 0; i < encounters.length; i++) {
-      if (this._encounterContainsAnswerConceptName(encounters[i], conceptName, valueConceptName)) return encounters[i];
+      if (this._encounterContainsAnswerConceptName(encounters[i], conceptNameOrUuid, valueConceptName)) return encounters[i];
     }
 
     return null;
   }
 
-  _encounterHasObsForConcept(encounter, conceptName) {
-    const observation = encounter.getObservationValue(conceptName);
+  _encounterHasObsForConcept(encounter, conceptNameOrUuid) {
+    const observation = encounter.getObservationValue(conceptNameOrUuid);
     return !_lodash.default.isNil(observation);
   }
 
-  findLatestPreviousEncounterWithObservationForConcept(currentEncounter, conceptName) {
+  findLatestPreviousEncounterWithObservationForConcept(currentEncounter, conceptNameOrUuid) {
     const encounters = _lodash.default.chain(this.getEncounters()).filter(enc => enc.encounterDateTime).filter(enc => enc.encounterDateTime < currentEncounter.encounterDateTime).value();
 
     for (let i = 0; i < encounters.length; i++) {
-      if (this._encounterHasObsForConcept(encounters[i], conceptName)) return encounters[i];
+      if (this._encounterHasObsForConcept(encounters[i], conceptNameOrUuid)) return encounters[i];
     }
 
     return null;
@@ -307,28 +307,28 @@ class ProgramEnrolment extends _BaseEntity.default {
     return _lodash.default.chain(this.getEncounters()).filter(enc => enc.encounterDateTime).filter(enc => enc.encounterDateTime < currentEncounter.encounterDateTime).filter(enc => encounterTypes.some(encounterType => encounterType === enc.encounterType.name)).nth(n).value();
   }
 
-  _encounterContainsAnswerConceptName(encounter, conceptName, valueConceptName) {
-    let observation = encounter.findObservation(conceptName);
+  _encounterContainsAnswerConceptName(encounter, conceptNameOrUuid, valueConceptName) {
+    let observation = encounter.findObservation(conceptNameOrUuid);
     return !_lodash.default.isNil(observation) && this._containsAnswerConceptName(valueConceptName, observation);
   }
 
-  _containsAnswerConceptName(conceptName, observation) {
-    const answerConcept = observation.concept.getPossibleAnswerConcept(conceptName);
+  _containsAnswerConceptName(conceptNameOrUuid, observation) {
+    const answerConcept = observation.concept.getPossibleAnswerConcept(conceptNameOrUuid);
     const answerUuid = answerConcept && answerConcept.concept.uuid;
     return observation.getValueWrapper().hasValue(answerUuid);
   }
 
-  _findObservationFromEntireEnrolment(conceptName, encounters, checkInEnrolment = true) {
-    return this._findObservationWithDateFromEntireEnrolment(conceptName, encounters, checkInEnrolment).observation;
+  _findObservationFromEntireEnrolment(conceptNameOrUuid, encounters, checkInEnrolment = true) {
+    return this._findObservationWithDateFromEntireEnrolment(conceptNameOrUuid, encounters, checkInEnrolment).observation;
   }
 
-  _findObservationWithDateFromEntireEnrolment(conceptName, encounters, checkInEnrolment = true) {
+  _findObservationWithDateFromEntireEnrolment(conceptNameOrUuid, encounters, checkInEnrolment = true) {
     let observation;
     let encounter;
 
     for (let i = 0; i < encounters.length; i++) {
       encounter = encounters[i];
-      observation = encounters[i].findObservation(conceptName);
+      observation = encounters[i].findObservation(conceptNameOrUuid);
       if (!_lodash.default.isNil(observation)) return {
         observation: observation,
         date: encounter.encounterDateTime
@@ -336,23 +336,25 @@ class ProgramEnrolment extends _BaseEntity.default {
     }
 
     if (checkInEnrolment) return {
-      observation: this.findObservation(conceptName),
+      observation: this.findObservation(conceptNameOrUuid),
       date: this.enrolmentDateTime
     };
     return {};
   }
 
-  getObservationReadableValueInEntireEnrolment(conceptName, programEncounter) {
-    let obs = this.findObservationInEntireEnrolment(conceptName, programEncounter);
+  getObservationReadableValueInEntireEnrolment(conceptNameOrUuid, programEncounter) {
+    let obs = this.findObservationInEntireEnrolment(conceptNameOrUuid, programEncounter);
     return obs ? obs.getReadableValue() : undefined;
   }
 
-  findObservation(conceptName) {
-    return _lodash.default.find(this.observations, observation => observation.concept.name === conceptName);
+  findObservation(conceptNameOrUuid) {
+    return _lodash.default.find(this.observations, observation => {
+      return observation.concept.name === conceptNameOrUuid || observation.concept.uuid === conceptNameOrUuid;
+    });
   }
 
-  findExitObservation(conceptName) {
-    return _lodash.default.find(this.programExitObservations, observation => observation.concept.name === conceptName);
+  findExitObservation(conceptNameOrUuid) {
+    return _lodash.default.find(this.programExitObservations, observation => observation.concept.name === conceptNameOrUuid || observation.concept.uuid === conceptNameOrUuid);
   }
 
   addChecklist(checklist) {
@@ -415,24 +417,24 @@ class ProgramEnrolment extends _BaseEntity.default {
     return encounterTypeNames.some(it => this.hasEncounterOfType(it));
   }
 
-  hasEncounterWithObservationValueAfterDate(encounterTypeName, afterDate, conceptName, value) {
-    const obsAfterDate = (0, _lodash.default)(this.getEncounters()).filter(en => (0, _moment.default)(en.encounterDateTime).isAfter(afterDate)).filter(en => en.encounterType.name === encounterTypeName).find(en => en.getObservationReadableValue(conceptName) === value);
+  hasEncounterWithObservationValueAfterDate(encounterTypeName, afterDate, conceptNameOrUuid, value) {
+    const obsAfterDate = (0, _lodash.default)(this.getEncounters()).filter(en => (0, _moment.default)(en.encounterDateTime).isAfter(afterDate)).filter(en => en.encounterType.name === encounterTypeName).find(en => en.getObservationReadableValue(conceptNameOrUuid) === value);
     return !_lodash.default.isNil(obsAfterDate);
   } //get has been taken by the prototype
 
 
-  getObservationValue(conceptName) {
-    const observationValue = this.findObservation(conceptName);
+  getObservationValue(conceptNameOrUuid) {
+    const observationValue = this.findObservation(conceptNameOrUuid);
     return _lodash.default.isEmpty(observationValue) ? undefined : observationValue.getValue();
   }
 
-  getObservationReadableValue(conceptName) {
-    const observationValue = this.findObservation(conceptName);
+  getObservationReadableValue(conceptNameOrUuid) {
+    const observationValue = this.findObservation(conceptNameOrUuid);
     return _lodash.default.isNil(observationValue) ? undefined : observationValue.getReadableValue();
   }
 
-  hasObservation(conceptName) {
-    return !_lodash.default.isNil(this.getObservationValue(conceptName));
+  hasObservation(conceptNameOrUuid) {
+    return !_lodash.default.isNil(this.getObservationValue(conceptNameOrUuid));
   }
 
   findMediaObservations() {

package/dist/application/Form.js

@@ -143,6 +143,53 @@ class Form {
     return orderedObservations.concat(extraObs);
   }
 
+  sectionWiseOrderedObservations(observations) {
+    const sections = [];
+    const allObservations = [];
+
+    const orderedFEG = _lodash.default.sortBy(this.formElementGroups, ({
+      displayOrder
+    }) => displayOrder);
+
+    _lodash.default.forEach(orderedFEG, feg => {
+      const conceptOrdering = _lodash.default.sortBy(feg.getFormElements(), fe => fe.displayOrder).map(fe => fe.concept);
+
+      const fegObs = [];
+
+      _lodash.default.forEach(conceptOrdering, concept => {
+        const foundObs = observations.find(obs => obs.concept.uuid === concept.uuid);
+        if (!_lodash.default.isNil(foundObs)) fegObs.push(foundObs);
+      });
+
+      if (!_lodash.default.isEmpty(fegObs)) {
+        sections.push({
+          groupName: feg.name,
+          groupUUID: feg.uuid,
+          observations: fegObs
+        });
+        allObservations.push(...fegObs);
+      }
+    });
+
+    const decisionObs = observations.filter(obs => _lodash.default.isNil(allObservations.find(oobs => oobs.concept.uuid === obs.concept.uuid)));
+    if (!_lodash.default.isEmpty(decisionObs)) sections.push({
+      groupName: 'decisions',
+      groupUUID: null,
+      observations: decisionObs
+    });
+    return sections;
+  }
+
+  getFormElementGroupOrder(groupUUID) {
+    const orderedFEG = _lodash.default.sortBy(this.nonVoidedFormElementGroups(), ({
+      displayOrder
+    }) => displayOrder);
+
+    return _lodash.default.findIndex(orderedFEG, ({
+      uuid
+    }) => uuid === groupUUID) + 1;
+  }
+
 }
 
 _defineProperty(Form, "schema", {

package/dist/application/FormElement.js

@@ -155,6 +155,10 @@ class FormElement {
     return _lodash.default.find(this.concept.getAnswers(), answer => answer.concept.name === conceptName);
   }
 
+  getAnswerWithConceptUuid(conceptUuid) {
+    return _lodash.default.find(this.concept.getAnswers(), answer => answer.concept.uuid === conceptUuid);
+  }
+
   getRawAnswers() {
     return this.concept.getAnswers();
   }
@@ -291,7 +295,7 @@ _defineProperty(FormElement, "keys", {
   allowedTypes: "allowedTypes",
   allowedMaxSize: "allowedMaxSize",
   displayAllGroupMembers: "displayAllGroupMembers",
-  allOptions: "allOptions"
+  searchOptions: "searchOptions"
 });
 
 _defineProperty(FormElement, "values", {

package/package.json

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