Add variable Extension support

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

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2021 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
+  }
+
+  override fun resolveConstantType(appContext: Any?, name: String?): TypeDetails {
+    TODO("Not yet implemented")
+  }
+
+  override fun log(argument: String?, focus: MutableList<Base>?): Boolean {
+    TODO("Not yet implemented")
+  }
+
+  override fun resolveFunction(
+    functionName: String?
+  ): FHIRPathEngine.IEvaluationContext.FunctionDetails {
+    TODO("Not yet implemented")
+  }
+
+  override fun checkFunction(
+    appContext: Any?,
+    functionName: String?,
+    parameters: MutableList<TypeDetails>?
+  ): TypeDetails {
+    TODO("Not yet implemented")
+  }
+
+  override fun executeFunction(
+    appContext: Any?,
+    focus: MutableList<Base>?,
+    functionName: String?,
+    parameters: MutableList<MutableList<Base>>?
+  ): MutableList<Base> {
+    TODO("Not yet implemented")
+  }
+
+  override fun resolveReference(appContext: Any?, url: String?): Base {
+    TODO("Not yet implemented")
+  }
+
+  override fun conformsToProfile(appContext: Any?, item: Base?, url: String?): Boolean {
+    TODO("Not yet implemented")
+  }
+
+  override fun resolveValueSet(appContext: Any?, url: String?): ValueSet {
+    TODO("Not yet implemented")
+  }
+}

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

@@ -23,6 +23,7 @@ import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.viewModelScope
 import ca.uhn.fhir.context.FhirContext
 import ca.uhn.fhir.context.FhirVersionEnum
+import ca.uhn.fhir.context.support.DefaultProfileValidationSupport
 import com.google.android.fhir.datacapture.enablement.EnablementEvaluator
 import com.google.android.fhir.datacapture.validation.QuestionnaireResponseValidator.checkQuestionnaireResponse
 import com.google.android.fhir.datacapture.views.QuestionnaireItemViewItem
@@ -31,12 +32,20 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.stateIn
+import org.hl7.fhir.exceptions.PathEngineException
+import org.hl7.fhir.instance.model.api.IBaseDatatype
+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.Extension
 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.Type
 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) :
@@ -103,6 +112,12 @@ internal class QuestionnaireViewModel(application: Application, state: SavedStat
   private val linkIdToQuestionnaireResponseItemMap =
     createLinkIdToQuestionnaireResponseItemMap(questionnaireResponse.item)
 
+  private val linkIdToQuestionnaireItemPathMap =
+    createLinkIdToQuestionnaireItemPathMap(questionnaire.item)
+
+  private val questionnaireResponseItemPathToVariableMap =
+    createQuestionnaireResponseItemPathToVariableMap(questionnaireResponse.item)
+
   /** Map from link IDs to questionnaire items. */
   private val linkIdToQuestionnaireItemMap = createLinkIdToQuestionnaireItemMap(questionnaire.item)
 
@@ -126,9 +141,183 @@ internal class QuestionnaireViewModel(application: Application, state: SavedStat
         }
       }
     }
+    calculateVariables()
     modificationCount.value += 1
   }
 
+  private fun calculateVariables() {
+    calculateRootVariables()
+
+    for ((key, _) in linkIdToQuestionnaireItemPathMap) {
+      linkIdToQuestionnaireItemMap[key]?.let { questionnaireItem ->
+        linkIdToQuestionnaireResponseItemMap[key]?.let { questionnaireResponseItem ->
+          calculateItemVariables(questionnaireItem, questionnaireResponseItem)
+        }
+      }
+    }
+  }
+
+  private fun calculateItemVariables(
+    questionnaireItem: Questionnaire.QuestionnaireItemComponent,
+    questionnaireResponseItem: QuestionnaireResponse.QuestionnaireResponseItemComponent
+  ) {
+    val fhirPathEngine: FHIRPathEngine =
+      with(FhirContext.forCached(FhirVersionEnum.R4)) {
+        FHIRPathEngine(HapiWorkerContext(this, DefaultProfileValidationSupport(this))).apply {
+          hostServices = FHIRPathEngineHostServices
+        }
+      }
+
+    questionnaireItem.extension.forEach { extension ->
+      if (extension.url == VARIABLE_EXTENSION_URL) {
+
+        val variableValue =
+          evaluateItemVariables(fhirPathEngine, extension, questionnaireResponseItem)
+
+        val variables =
+          questionnaireResponseItemPathToVariableMap[
+            linkIdToQuestionnaireItemPathMap[questionnaireResponseItem.linkId]]
+        updateVariable(variables, extension, variableValue)
+      }
+    }
+  }
+
+  private fun updateVariable(
+    variables: MutableList<Variable>?,
+    extension: Extension,
+    variableValue: Any?
+  ) {
+    variables?.find { it.id == (extension.value as Expression).name }.also { variable ->
+      if (variable == null) {
+        variableValue?.let {
+          variables?.add(Variable(id = (extension.value as Expression).name, value = it as Type))
+        }
+      } else {
+        if (variableValue != null) variable.value = variableValue as Type
+        else variables?.remove(variable)
+      }
+    }
+  }
+
+  private fun evaluateItemVariables(
+    fhirPathEngine: FHIRPathEngine,
+    extension: Extension,
+    questionnaireResponseItem: QuestionnaireResponse.QuestionnaireResponseItemComponent
+  ) =
+    try {
+      fhirPathEngine
+        .evaluate(
+          findAncestorVariables(extension, questionnaireResponseItem),
+          questionnaireResponse,
+          questionnaireResponse,
+          questionnaireResponse,
+          (extension.value as Expression).expression
+        )
+        .firstOrNull()
+    } catch (exception: PathEngineException) {
+      Timber.d("Could not evaluate expression with FHIRPathEngine", exception)
+    }
+
+  private fun calculateRootVariables() {
+    val fhirPathEngine: FHIRPathEngine =
+      with(FhirContext.forCached(FhirVersionEnum.R4)) {
+        FHIRPathEngine(HapiWorkerContext(this, DefaultProfileValidationSupport(this))).apply {
+          hostServices = FHIRPathEngineHostServices
+        }
+      }
+
+    questionnaire.extension.forEach { extension ->
+      if (extension.url == VARIABLE_EXTENSION_URL) {
+
+        val variableValue = evaluateRootVariables(fhirPathEngine, extension)
+
+        if (questionnaireResponseItemPathToVariableMap.containsKey(ROOT_VARIABLES)) {
+          val variables = questionnaireResponseItemPathToVariableMap[ROOT_VARIABLES]
+          updateVariable(variables, extension, variableValue)
+        } else {
+          questionnaireResponseItemPathToVariableMap[ROOT_VARIABLES] =
+            mutableListOf(
+              Variable(id = (extension.value as Expression).name, value = variableValue as Type)
+            )
+        }
+      }
+    }
+  }
+
+  private fun evaluateRootVariables(fhirPathEngine: FHIRPathEngine, extension: Extension): Base? =
+    try {
+      fhirPathEngine
+        .evaluate(
+          findRootVariables(extension),
+          questionnaireResponse,
+          questionnaireResponse,
+          questionnaireResponse,
+          (extension.value as Expression).expression
+        )
+        .firstOrNull()
+    } catch (exception: PathEngineException) {
+      Timber.d("Could not evaluate expression with FHIRPathEngine", exception)
+      null
+    }
+
+  private fun findRootVariables(extension: Extension): Map<String, Any> {
+    val map = mutableMapOf<String, Base>()
+    if (questionnaireResponseItemPathToVariableMap.containsKey(ROOT_VARIABLES)) {
+      val variables = questionnaireResponseItemPathToVariableMap[ROOT_VARIABLES]
+      variables?.forEach {
+        if (it.id != (extension.value as Expression).name) {
+          map[it.id] = it.value as Type
+        }
+      }
+    }
+    return map
+  }
+
+  private fun findAncestorVariables(
+    extension: Extension,
+    questionnaireResponseItem: QuestionnaireResponse.QuestionnaireResponseItemComponent
+  ): Map<String, Any> {
+    val map = mutableMapOf<String, Base>()
+
+    // check root level variables
+    if (questionnaireResponseItemPathToVariableMap.containsKey(ROOT_VARIABLES)) {
+      val rootVariables = questionnaireResponseItemPathToVariableMap[ROOT_VARIABLES]
+      rootVariables?.forEach {
+        if (it.id != (extension.value as Expression).name) {
+          map[it.id] = it.value as Type
+        }
+      }
+    }
+
+    // check variables in ancestors
+    var path = linkIdToQuestionnaireItemPathMap[questionnaireResponseItem.linkId]
+    do {
+      if (path?.contains(".") == true) {
+        path = path.substringBeforeLast(".")
+        val variables = questionnaireResponseItemPathToVariableMap[path]
+        variables?.forEach {
+          if (it.id != (extension.value as Expression).name) {
+            map[it.id] = it.value as Type
+          }
+        }
+      } else {
+        path = ""
+      }
+    } while (path?.isNotEmpty() == true)
+
+    // check current item variables
+    val itemVariables =
+      questionnaireResponseItemPathToVariableMap[
+        linkIdToQuestionnaireItemPathMap[questionnaireResponseItem.linkId]]
+    itemVariables?.forEach {
+      if (it.id != (extension.value as Expression).name) {
+        map[it.id] = it.value as Type
+      }
+    }
+
+    return map
+  }
+
   private val pageFlow = MutableStateFlow(questionnaire.getInitialPagination())
 
   private val answerValueSetMap =
@@ -229,6 +418,46 @@ internal class QuestionnaireViewModel(application: Application, state: SavedStat
     return linkIdToQuestionnaireResponseItemMap
   }
 
+  private fun createLinkIdToQuestionnaireItemPathMap(
+    questionnaireItemList: List<Questionnaire.QuestionnaireItemComponent>,
+    pathPrefix: String = ""
+  ): MutableMap<String, String> {
+
+    val linkIdToQuestionnaireItemPathMap =
+      questionnaireItemList
+        .associate { it.linkId to if (pathPrefix == "") it.linkId else "$pathPrefix.${it.linkId}" }
+        .toMutableMap()
+
+    for (item in questionnaireItemList) {
+      linkIdToQuestionnaireItemPathMap.putAll(
+        createLinkIdToQuestionnaireItemPathMap(
+          item.item,
+          if (pathPrefix == "") item.linkId else "$pathPrefix.${item.linkId}"
+        )
+      )
+    }
+    return linkIdToQuestionnaireItemPathMap
+  }
+
+  private fun createQuestionnaireResponseItemPathToVariableMap(
+    questionnaireResponseItemList: List<QuestionnaireResponse.QuestionnaireResponseItemComponent>
+  ): MutableMap<String, MutableList<Variable>> {
+    val questionnaireResponseItemPathToVariableMap =
+      questionnaireResponseItemList
+        .associate { questionnaireResponseItem ->
+          linkIdToQuestionnaireItemPathMap[questionnaireResponseItem.linkId]!! to
+            mutableListOf<Variable>()
+        }
+        .toMutableMap()
+
+    for (item in questionnaireResponseItemList) {
+      questionnaireResponseItemPathToVariableMap.putAll(
+        createQuestionnaireResponseItemPathToVariableMap(item.item)
+      )
+    }
+    return questionnaireResponseItemPathToVariableMap
+  }
+
   private fun createLinkIdToQuestionnaireItemMap(
     questionnaireItemList: List<Questionnaire.QuestionnaireItemComponent>
   ): Map<String, Questionnaire.QuestionnaireItemComponent> {
@@ -400,3 +629,8 @@ internal fun QuestionnairePagination.nextPage(): QuestionnairePagination {
   check(hasNextPage) { "Can't call nextPage() if hasNextPage is false ($this)" }
   return copy(currentPageIndex = currentPageIndex + 1)
 }
+
+data class Variable(val id: String, var value: IBaseDatatype)
+
+internal const val VARIABLE_EXTENSION_URL = "http://hl7.org/fhir/StructureDefinition/variable"
+internal const val ROOT_VARIABLES = "root_variables"