Add variable Extension support

datacapture/src/main/java/com/google/android/fhir/datacapture/FHIRPathEngineHostServices.kt

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.fhir.datacapture
+
+import org.hl7.fhir.r4.model.Base
+import org.hl7.fhir.r4.model.TypeDetails
+import org.hl7.fhir.r4.model.ValueSet
+import org.hl7.fhir.r4.utils.FHIRPathEngine
+
+object FHIRPathEngineHostServices : FHIRPathEngine.IEvaluationContext {
+  override fun resolveConstant(appContext: Any?, name: String?, beforeContext: Boolean): Base? {
+    return if ((appContext as Map<*, *>).containsKey(name)) appContext[name] as Base else null
+  }
+
+  @Throws(UnsupportedOperationException::class)
+  override fun resolveConstantType(appContext: Any?, name: String?): TypeDetails {
+    throw UnsupportedOperationException()
+  }
+
+  @Throws(UnsupportedOperationException::class)
+  override fun log(argument: String?, focus: MutableList<Base>?): Boolean {
+    throw UnsupportedOperationException()
+  }
+
+  @Throws(UnsupportedOperationException::class)
+  override fun resolveFunction(
+    functionName: String?
+  ): FHIRPathEngine.IEvaluationContext.FunctionDetails {
+    throw UnsupportedOperationException()
+  }
+
+  @Throws(UnsupportedOperationException::class)
+  override fun checkFunction(
+    appContext: Any?,
+    functionName: String?,
+    parameters: MutableList<TypeDetails>?
+  ): TypeDetails {
+    throw UnsupportedOperationException()
+  }
+
+  @Throws(UnsupportedOperationException::class)
+  override fun executeFunction(
+    appContext: Any?,
+    focus: MutableList<Base>?,
+    functionName: String?,
+    parameters: MutableList<MutableList<Base>>?
+  ): MutableList<Base> {
+    throw UnsupportedOperationException()
+  }
+
+  @Throws(UnsupportedOperationException::class)
+  override fun resolveReference(appContext: Any?, url: String?): Base {
+    throw UnsupportedOperationException()
+  }
+
+  @Throws(UnsupportedOperationException::class)
+  override fun conformsToProfile(appContext: Any?, item: Base?, url: String?): Boolean {
+    throw UnsupportedOperationException()
+  }
+
+  @Throws(UnsupportedOperationException::class)
+  override fun resolveValueSet(appContext: Any?, url: String?): ValueSet {
+    throw UnsupportedOperationException()
+  }
+}

datacapture/src/main/java/com/google/android/fhir/datacapture/MoreQuestionnaireItemComponents.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 Google LLC
+ * Copyright 2022 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -62,6 +62,12 @@ internal const val EXTENSION_ENTRY_FORMAT_URL =
 internal const val ITEM_ENABLE_WHEN_EXPRESSION_URL: String =
   "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-enableWhenExpression"
 
+internal const val VARIABLE_EXTENSION_URL = "http://hl7.org/fhir/StructureDefinition/variable"
+
+internal val Questionnaire.QuestionnaireItemComponent.variableExpressions: List<Expression>
+  get() =
+    this.extension.filter { it.url == VARIABLE_EXTENSION_URL }.map { it.castToExpression(it.value) }
+
 // Item control code, or null
 internal val Questionnaire.QuestionnaireItemComponent.itemControl: ItemControlTypes?
   get() {

datacapture/src/main/java/com/google/android/fhir/datacapture/MoreQuestionnaires.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 Google LLC
+ * Copyright 2022 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,6 +17,7 @@
 package com.google.android.fhir.datacapture
 
 import org.hl7.fhir.r4.model.CanonicalType
+import org.hl7.fhir.r4.model.Expression
 import org.hl7.fhir.r4.model.Questionnaire
 
 /**
@@ -31,6 +32,10 @@ val Questionnaire.targetStructureMap: String?
     return if (extensionValue is CanonicalType) extensionValue.valueAsString else null
   }
 
+internal val Questionnaire.variableExpressions: List<Expression>
+  get() =
+    this.extension.filter { it.url == VARIABLE_EXTENSION_URL }.map { it.castToExpression(it.value) }
+
 /**
  * See
  * [Extension: target structure map](http://build.fhir.org/ig/HL7/sdc/StructureDefinition-sdc-questionnaire-targetStructureMap.html)

datacapture/src/main/java/com/google/android/fhir/datacapture/QuestionnaireViewModel.kt

@@ -35,12 +35,17 @@ import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.update
+import org.hl7.fhir.exceptions.FHIRException
+import org.hl7.fhir.r4.hapi.ctx.HapiWorkerContext
+import org.hl7.fhir.r4.model.Base
 import org.hl7.fhir.r4.model.CodeableConcept
 import org.hl7.fhir.r4.model.Coding
+import org.hl7.fhir.r4.model.Expression
 import org.hl7.fhir.r4.model.Questionnaire
 import org.hl7.fhir.r4.model.QuestionnaireResponse
 import org.hl7.fhir.r4.model.ResourceType
 import org.hl7.fhir.r4.model.ValueSet
+import org.hl7.fhir.r4.utils.FHIRPathEngine
 import timber.log.Timber
 
 internal class QuestionnaireViewModel(application: Application, state: SavedStateHandle) :
@@ -145,6 +150,25 @@ internal class QuestionnaireViewModel(application: Application, state: SavedStat
     }
   }
 
+  /** The map from each item in the [Questionnaire] to its parent. */
+  private val questionnaireItemParentMap =
+    mutableMapOf<
+      Questionnaire.QuestionnaireItemComponent, Questionnaire.QuestionnaireItemComponent>()
+
+  init {
+    /** Adds each child-parent pair in the [Questionnaire] to the parent map. */
+    fun buildParentList(item: Questionnaire.QuestionnaireItemComponent) {
+      for (child in item.item) {
+        questionnaireItemParentMap[child] = item
+        buildParentList(child)
+      }
+    }
+
+    for (item in questionnaire.item) {
+      buildParentList(item)
+    }
+  }
+
   /** The map from each item in the [QuestionnaireResponse] to its parent. */
   private val questionnaireResponseItemParentMap =
     mutableMapOf<
@@ -168,6 +192,13 @@ internal class QuestionnaireViewModel(application: Application, state: SavedStat
   /** Tracks modifications in order to update the UI. */
   private val modificationCount = MutableStateFlow(0)
 
+  private val fhirPathEngine: FHIRPathEngine =
+    with(FhirContext.forCached(FhirVersionEnum.R4)) {
+      FHIRPathEngine(HapiWorkerContext(this, this.validationSupport)).apply {
+        hostServices = FHIRPathEngineHostServices
+      }
+    }
+
   /**
    * Contains [QuestionnaireResponse.QuestionnaireResponseItemComponent]s that have been modified by
    * the user. [QuestionnaireResponse.QuestionnaireResponseItemComponent]s that have not been
@@ -496,6 +527,168 @@ internal class QuestionnaireViewModel(application: Application, state: SavedStat
 
     return null
   }
+
+  /**
+   * This function is to evaluate expression either calculated expression or variable expression The
+   * function first evaluates the expression, if found null, then parse the expression and find the
+   * related variable values from same questionnaireItem [Questionnaire.QuestionnaireItemComponent],
+   * also find in parent hierarchy of current origin [Questionnaire.QuestionnaireItemComponent] also
+   * find at questionnaire/root[Questionnaire] level and calculate and return the result of
+   * expression recursively,
+   *
+   * @param expression the [Expression] Either Variable expression or Calculated expression
+   * @param origin the [Questionnaire.QuestionnaireItemComponent] where this expression is defined,
+   * null if expression defined at questionnaire [Questionnaire] level
+   *
+   * @return [Base] the result of expression
+   */
+  internal fun evaluateExpression(
+    expression: Expression,
+    origin: Questionnaire.QuestionnaireItemComponent? = null
+  ): Base? {
+
+    val result = evaluateVariable(expression)
+    if (result != null) {
+      return result
+    }
+
+    buildMap<String, Base?> {
+      buildList {
+        val variableRegex = Regex("[%]([A-Za-z0-9\\-]{1,64})")
+        val variableMatches = variableRegex.findAll(expression.expression)
+
+        addAll(
+          variableMatches.map { it.groupValues[1] }.toList().filterNot { variable ->
+            reservedVariables.any { it == variable }
+          }
+        )
+      }
+        .takeIf { it.isNotEmpty() }
+        ?.forEach { variableName ->
+          findVariable(variableName, origin)?.also { (questionnaireItem, expression) ->
+            put(expression.name, evaluateExpression(expression, questionnaireItem))
+          }
+        }
+    }
+      .also {
+        return evaluateVariable(expression, it)
+      }
+  }
+
+  /**
+   * function to find a variable, first check at origin if not found, then check in parent
+   * hierarchy, if not found, then check at root level and return the Pair
+   *
+   * @param variableName the [String] to match the variable
+   * @param origin the [Questionnaire.QuestionnaireItemComponent] from where we have to track
+   * hierarchy
+   *
+   * @return [Pair] containing [Questionnaire.QuestionnaireItemComponent] and [Expression]
+   */
+  private fun findVariable(
+    variableName: String,
+    origin: Questionnaire.QuestionnaireItemComponent?
+  ): Pair<Questionnaire.QuestionnaireItemComponent?, Expression>? {
+    return findVariableAtOrigin(variableName, origin)
+      ?: findVariableInParent(variableName, origin) ?: findVariableAtRoot(variableName)
+  }
+
+  /**
+   * This function find the specific variable name [String] at the origin
+   * [Questionnaire.QuestionnaireItemComponent]
+   *
+   * @param origin the [Questionnaire.QuestionnaireItemComponent] from where we have to track
+   * hierarchy up in the parent
+   * @param variableName the [String] to match the variable in the parent hierarchy
+   *
+   * @return [Pair] containing [Questionnaire.QuestionnaireItemComponent] and [Expression]
+   */
+  private fun findVariableAtOrigin(
+    variableName: String,
+    origin: Questionnaire.QuestionnaireItemComponent? = null
+  ): Pair<Questionnaire.QuestionnaireItemComponent?, Expression>? {
+    origin?.variableExpressions?.find { it.name == variableName }.also {
+      it?.let {
+        return Pair(origin, it)
+      }
+    }
+    return null
+  }
+
+  /**
+   * This function find the specific variable name [String] in the parent hierarchy of origin
+   * [Questionnaire.QuestionnaireItemComponent]
+   *
+   * @param origin the [Questionnaire.QuestionnaireItemComponent] from where we have to track
+   * hierarchy up in the parent
+   * @param variableName the [String] to match the variable in the parent hierarchy
+   *
+   * @return [Pair] containing [Questionnaire.QuestionnaireItemComponent] and [Expression]
+   */
+  private fun findVariableInParent(
+    variableName: String,
+    origin: Questionnaire.QuestionnaireItemComponent? = null
+  ): Pair<Questionnaire.QuestionnaireItemComponent?, Expression>? {
+    var parent = questionnaireItemParentMap[origin]
+    while (parent != null) {
+      parent.variableExpressions.find { it.name == variableName }.also {
+        it?.let {
+          return Pair(parent!!, it)
+        }
+      }
+      parent = questionnaireItemParentMap[parent]
+    }
+    return null
+  }
+
+  /**
+   * This function find the specific variable name [String] at root/questionnaire [Questionnaire]
+   * level
+   *
+   * @param variableName the [String] to match the variable at questionnaire [Questionnaire] level
+   *
+   * @return [Expression] the matching expression
+   */
+  private fun findVariableAtRoot(
+    variableName: String
+  ): Pair<Questionnaire.QuestionnaireItemComponent?, Expression>? {
+    questionnaire.variableExpressions.find { it.name == variableName }.also {
+      it?.let {
+        return Pair(null, it)
+      }
+    }
+    return null
+  }
+
+  /**
+   * function to evaluate the value of variable expression and return the evaluated value
+   *
+   * @param expression the [Expression] the expression to evaluate
+   * @param inputVariables the [Map] of Variable names to their values
+   *
+   * @return [Base] the result of expression
+   */
+  private fun evaluateVariable(
+    expression: Expression,
+    inputVariables: Map<String, Base?> = mapOf()
+  ) =
+    try {
+
+      require(!expression.name.isNullOrEmpty()) {
+        "Expression name should be a valid expression name"
+      }
+
+      require(expression.hasLanguage() && expression.language == "text/fhirpath") {
+        "Unsupported expression language, language should be text/fhirpath"
+      }
+
+      fhirPathEngine
+        .evaluate(inputVariables, questionnaireResponse, null, null, expression.expression)
+        .firstOrNull()
+    } catch (exception: FHIRException) {
+      Timber.w("Could not evaluate expression with FHIRPathEngine", exception)
+      null
+    }
 }
 
 /** Questionnaire state for the Fragment to consume. */
@@ -527,3 +720,6 @@ internal fun QuestionnairePagination.nextPage(): QuestionnairePagination {
   check(hasNextPage) { "Can't call nextPage() if hasNextPage is false ($this)" }
   return copy(currentPageIndex = currentPageIndex + 1)
 }
+
+private val reservedVariables =
+  listOf("sct", "loinc", "ucum", "resource", "rootResource", "context", "map-codes")