diff --git a/android/engine/src/main/java/org/smartregister/fhircore/engine/configuration/QuestionnaireConfig.kt b/android/engine/src/main/java/org/smartregister/fhircore/engine/configuration/QuestionnaireConfig.kt index b202cc6216..437546ed37 100644 --- a/android/engine/src/main/java/org/smartregister/fhircore/engine/configuration/QuestionnaireConfig.kt +++ b/android/engine/src/main/java/org/smartregister/fhircore/engine/configuration/QuestionnaireConfig.kt @@ -54,6 +54,7 @@ data class QuestionnaireConfig( val extractedResourceUniquePropertyExpressions: List? = null, val saveQuestionnaireResponse: Boolean = true, + val generateCarePlanWithWorkflowApi: Boolean = false, ) : java.io.Serializable, Parcelable { fun interpolate(computedValuesMap: Map) = diff --git a/android/engine/src/main/java/org/smartregister/fhircore/engine/task/FhirCarePlanGenerator.kt b/android/engine/src/main/java/org/smartregister/fhircore/engine/task/FhirCarePlanGenerator.kt index 44d4f26517..d7836fd462 100644 --- a/android/engine/src/main/java/org/smartregister/fhircore/engine/task/FhirCarePlanGenerator.kt +++ b/android/engine/src/main/java/org/smartregister/fhircore/engine/task/FhirCarePlanGenerator.kt @@ -39,6 +39,7 @@ import org.hl7.fhir.r4.model.Expression import org.hl7.fhir.r4.model.IdType import org.hl7.fhir.r4.model.IntegerType import org.hl7.fhir.r4.model.Parameters +import org.hl7.fhir.r4.model.Patient import org.hl7.fhir.r4.model.Period import org.hl7.fhir.r4.model.PlanDefinition import org.hl7.fhir.r4.model.Resource @@ -74,6 +75,7 @@ constructor( val transformSupportServices: TransformSupportServices, val defaultRepository: DefaultRepository, val fhirResourceUtil: FhirResourceUtil, + val workflowCarePlanGenerator: WorkflowCarePlanGenerator, ) { private val structureMapUtilities by lazy { StructureMapUtilities(transformSupportServices.simpleWorkerContext, transformSupportServices) @@ -83,15 +85,19 @@ constructor( planDefinitionId: String, subject: Resource, data: Bundle = Bundle(), + generateCarePlanWithWorkflowApi: Boolean = false, ): CarePlan? { val planDefinition = defaultRepository.loadResource(planDefinitionId) - return planDefinition?.let { generateOrUpdateCarePlan(it, subject, data) } + return planDefinition?.let { + generateOrUpdateCarePlan(it, subject, data, generateCarePlanWithWorkflowApi) + } } suspend fun generateOrUpdateCarePlan( planDefinition: PlanDefinition, subject: Resource, data: Bundle = Bundle(), + generateCarePlanWithWorkflowApi: Boolean = false, ): CarePlan? { // Only one CarePlan per plan, update or init a new one if not exists val output = @@ -112,59 +118,69 @@ constructor( var carePlanModified = false - planDefinition.action.forEach { action -> - val input = Bundle().apply { entry.addAll(data.entry) } - - if (action.passesConditions(input, planDefinition, subject)) { - val definition = action.activityDefinition(planDefinition) - - if (action.hasTransform()) { - val taskPeriods = action.taskPeriods(definition, output) - - taskPeriods.forEachIndexed { index, period -> - val source = - Parameters().apply { - addResourceParameter(CarePlan.SP_SUBJECT, subject) - addResourceParameter(PlanDefinition.SP_DEFINITION, definition) - // TODO find some other way (activity definition based) to pass additional data - addResourceParameter(PlanDefinition.SP_DEPENDS_ON, data) - } - source.setParameter(Task.SP_PERIOD, period) - source.setParameter(ActivityDefinition.SP_VERSION, IntegerType(index)) - - val structureMap = fhirEngine.get(IdType(action.transform).idPart) - structureMapUtilities.transform( - transformSupportServices.simpleWorkerContext, - source, - structureMap, - output, - ) + if (generateCarePlanWithWorkflowApi) { + workflowCarePlanGenerator.applyPlanDefinitionOnPatient( + planDefinition = planDefinition, + patient = subject as Patient, + data = data, + output = output, + ) + carePlanModified = true + } else { + planDefinition.action.forEach { action -> + val input = Bundle().apply { entry.addAll(data.entry) } + + if (action.passesConditions(input, planDefinition, subject)) { + val definition = action.activityDefinition(planDefinition) + + if (action.hasTransform()) { + val taskPeriods = action.taskPeriods(definition, output) + + taskPeriods.forEachIndexed { index, period -> + val source = + Parameters().apply { + addResourceParameter(CarePlan.SP_SUBJECT, subject) + addResourceParameter(PlanDefinition.SP_DEFINITION, definition) + // TODO find some other way (activity definition based) to pass additional data + addResourceParameter(PlanDefinition.SP_DEPENDS_ON, data) + } + source.setParameter(Task.SP_PERIOD, period) + source.setParameter(ActivityDefinition.SP_VERSION, IntegerType(index)) + + val structureMap = fhirEngine.get(IdType(action.transform).idPart) + structureMapUtilities.transform( + transformSupportServices.simpleWorkerContext, + source, + structureMap, + output, + ) + } } - } - if (definition.hasDynamicValue()) { - definition.dynamicValue.forEach { dynamicValue -> - if (definition.kind == ActivityDefinition.ActivityDefinitionKind.CAREPLAN) { - dynamicValue.expression.expression - .let { fhirPathEngine.evaluate(null, input, planDefinition, subject, it) } - ?.takeIf { it.isNotEmpty() } - ?.let { evaluatedValue -> - // TODO handle cases where we explicitly need to set previous value as null, when - // passing null to Terser, it gives error NPE - Timber.d("${dynamicValue.path}, evaluatedValue: $evaluatedValue") - TerserUtil.setFieldByFhirPath( - FhirContext.forR4Cached(), - dynamicValue.path.removePrefix("${definition.kind.display}."), - output, - evaluatedValue.first(), - ) - } - } else { - throw UnsupportedOperationException("${definition.kind} not supported") + if (definition.hasDynamicValue()) { + definition.dynamicValue.forEach { dynamicValue -> + if (definition.kind == ActivityDefinition.ActivityDefinitionKind.CAREPLAN) { + dynamicValue.expression.expression + .let { fhirPathEngine.evaluate(null, input, planDefinition, subject, it) } + ?.takeIf { it.isNotEmpty() } + ?.let { evaluatedValue -> + // TODO handle cases where we explicitly need to set previous value as null, + // when passing null to Terser, it gives error NPE + Timber.d("${dynamicValue.path}, evaluatedValue: $evaluatedValue") + TerserUtil.setFieldByFhirPath( + FhirContext.forR4Cached(), + dynamicValue.path.removePrefix("${definition.kind.display}."), + output, + evaluatedValue.first(), + ) + } + } else { + throw UnsupportedOperationException("${definition.kind} not supported") + } } } + carePlanModified = true } - carePlanModified = true } } diff --git a/android/engine/src/main/java/org/smartregister/fhircore/engine/task/WorkflowCarePlanGenerator.kt b/android/engine/src/main/java/org/smartregister/fhircore/engine/task/WorkflowCarePlanGenerator.kt new file mode 100644 index 0000000000..631eed0827 --- /dev/null +++ b/android/engine/src/main/java/org/smartregister/fhircore/engine/task/WorkflowCarePlanGenerator.kt @@ -0,0 +1,363 @@ +/* + * Copyright 2021-2023 Ona Systems, Inc + * + * 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 org.smartregister.fhircore.engine.task + +import android.content.Context +import ca.uhn.fhir.context.FhirContext +import ca.uhn.fhir.context.FhirVersionEnum +import ca.uhn.fhir.util.TerserUtil +import com.google.android.fhir.FhirEngine +import com.google.android.fhir.knowledge.KnowledgeManager +import com.google.android.fhir.search.Search +import com.google.android.fhir.workflow.FhirOperator +import dagger.hilt.android.qualifiers.ApplicationContext +import java.io.File +import javax.inject.Inject +import javax.inject.Singleton +import kotlin.reflect.full.declaredMemberProperties +import kotlin.reflect.jvm.isAccessible +import org.hl7.fhir.instance.model.api.IBaseParameters +import org.hl7.fhir.instance.model.api.IBaseResource +import org.hl7.fhir.r4.model.Bundle +import org.hl7.fhir.r4.model.CarePlan +import org.hl7.fhir.r4.model.IdType +import org.hl7.fhir.r4.model.Library +import org.hl7.fhir.r4.model.MetadataResource +import org.hl7.fhir.r4.model.Parameters +import org.hl7.fhir.r4.model.Patient +import org.hl7.fhir.r4.model.PlanDefinition +import org.hl7.fhir.r4.model.Reference +import org.hl7.fhir.r4.model.Resource +import org.hl7.fhir.r4.model.ResourceType +import org.hl7.fhir.r4.model.Task +import org.hl7.fhir.r4.utils.FHIRPathEngine +import org.opencds.cqf.cql.evaluator.activitydefinition.r4.ActivityDefinitionProcessor +import org.opencds.cqf.cql.evaluator.expression.ExpressionEvaluator +import org.opencds.cqf.cql.evaluator.fhir.dal.FhirDal +import org.opencds.cqf.cql.evaluator.library.LibraryProcessor +import org.opencds.cqf.cql.evaluator.plandefinition.OperationParametersParser +import org.opencds.cqf.cql.evaluator.plandefinition.r4.PlanDefinitionProcessor +import org.smartregister.fhircore.engine.data.local.DefaultRepository +import timber.log.Timber + +@Singleton +class WorkflowCarePlanGenerator +@Inject +constructor( + val knowledgeManager: KnowledgeManager, + val fhirOperator: FhirOperator, + val defaultRepository: DefaultRepository, + val fhirPathEngine: FHIRPathEngine, + @ApplicationContext val context: Context, +) { + + private var cqlLibraryIdList = ArrayList() + private val fhirContext = FhirContext.forCached(FhirVersionEnum.R4) + private val jsonParser = fhirContext.newJsonParser() + + private fun writeToFile(resource: Resource): File { + val fileName = + if (resource is MetadataResource && resource.name != null) { + resource.name + } else { + resource.idElement.idPart + } + return File(context.filesDir, fileName).apply { + writeText(jsonParser.encodeResourceToString(resource)) + } + } + + /** + * Extracts resources present in PlanDefinition.contained field + * + * We cannot use $data-requirements on the [PlanDefinition] yet. So, we assume that all knowledge + * resources required to $apply a [PlanDefinition] are present within `PlanDefinition.contained` + * + * @param planDefinition PlanDefinition resource for which dependent resources are extracted + */ + suspend fun getPlanDefinitionDependentResources( + planDefinition: PlanDefinition, + ): Collection { + var bundleCollection: Collection = mutableListOf() + + for (resource in planDefinition.contained) { + resource.meta.lastUpdated = planDefinition.meta.lastUpdated + if (resource is Library) { + cqlLibraryIdList.add(IdType(resource.id).idPart) + } + knowledgeManager.install(writeToFile(resource)) + + bundleCollection += resource + } + return bundleCollection + } + + /** + * Knowledge resources are loaded from [FhirEngine] and installed so that they may be used when + * running $apply on a [PlanDefinition] + */ + private suspend fun loadPlanDefinitionResourcesFromDb() { + // Load Library resources + val availableCqlLibraries = defaultRepository.search(Search(ResourceType.Library)) + val availablePlanDefinitions = + defaultRepository.search(Search(ResourceType.PlanDefinition)) + for (cqlLibrary in availableCqlLibraries) { + fhirOperator.loadLib(cqlLibrary) + knowledgeManager.install(writeToFile(cqlLibrary)) + cqlLibraryIdList.add(IdType(cqlLibrary.id).idPart) + } + for (planDefinition in availablePlanDefinitions) { + getPlanDefinitionDependentResources(planDefinition) + } + } + + /** + * Executes $apply on a [PlanDefinition] for a [Patient] and creates the request resources as per + * the proposed [CarePlan] + * + * @param planDefinitionId PlanDefinition resource ID for which $apply is run + * @param patient Patient resource for which the [PlanDefinition] $apply is run + * @param requestResourceConfigs List of configurations that need to be applied to the request + * resources as a result of the proposed [CarePlan] + */ + suspend fun applyPlanDefinitionOnPatient( + planDefinition: PlanDefinition, + patient: Patient, + data: Bundle = Bundle(), + output: CarePlan, + ) { + val patientId = IdType(patient.id).idPart + val planDefinitionId = IdType(planDefinition.id).idPart + + if (cqlLibraryIdList.isEmpty()) { + loadPlanDefinitionResourcesFromDb() + } + + val r4PlanDefinitionProcessor = createPlanDefinitionProcessor() + val carePlanProposal = + r4PlanDefinitionProcessor.apply( + IdType("PlanDefinition", planDefinitionId), + patientId, + null, + null, + null, + null, + null, + null, + null, + null, + null, + Parameters(), + null, + null, + null, + null, + null, + null, + ) as CarePlan + + // Accept the proposed (transient) CarePlan by default and add tasks to the CarePlan of record + acceptCarePlan(carePlanProposal, output) + + resolveDynamicValues( + planDefinition = planDefinition, + input = data, + subject = patient, + output, + ) + } + + private fun createPlanDefinitionProcessor(): R4PlanDefinitionProcessor { + val fhirDal = getPrivateProperty("fhirEngineDal", fhirOperator) as FhirDal + val libraryProcessor = getPrivateProperty("libraryProcessor", fhirOperator) as LibraryProcessor + val expressionEvaluator = + getPrivateProperty("expressionEvaluator", fhirOperator) as ExpressionEvaluator + val activityDefinitionProcessor = + getPrivateProperty("activityDefinitionProcessor", fhirOperator) as ActivityDefinitionProcessor + val operationParametersParser = + getPrivateProperty("operationParametersParser", fhirOperator) as OperationParametersParser + + return R4PlanDefinitionProcessor( + fhirContext = fhirContext, + fhirDal = fhirDal, + libraryProcessor = libraryProcessor, + expressionEvaluator = expressionEvaluator, + activityDefinitionProcessor = activityDefinitionProcessor, + operationParametersParser = operationParametersParser, + ) + } + + private fun resolveDynamicValues( + planDefinition: PlanDefinition, + input: Bundle, + subject: Patient, + output: CarePlan, + ) { + for (action in planDefinition.action) { + if (action.hasDynamicValue()) { + action.dynamicValue.forEach { dynamicValue -> + dynamicValue.expression.expression + .let { fhirPathEngine.evaluate(null, input, planDefinition, subject, it) } + ?.takeIf { it.isNotEmpty() } + ?.let { evaluatedValue -> + Timber.d("${dynamicValue.path}, evaluatedValue: $evaluatedValue") + TerserUtil.setFieldByFhirPath( + FhirContext.forR4Cached(), + dynamicValue.path, + output, + evaluatedValue.first(), + ) + } + } + } + } + } + + /** Link the request resources created for the [Patient] back to the [CarePlan] of record */ + private fun addRequestResourcesToCarePlanOfRecord( + carePlan: CarePlan, + requestResourceList: List, + ) { + for (resource in requestResourceList) { + when (resource.fhirType()) { + "Task" -> + carePlan.addActivity().setReference(Reference(resource)).detail.status = + mapRequestResourceStatusToCarePlanStatus(resource as Task) + "ServiceRequest" -> TODO("Not supported yet") + "MedicationRequest" -> TODO("Not supported yet") + "SupplyRequest" -> TODO("Not supported yet") + "Procedure" -> TODO("Not supported yet") + "DiagnosticReport" -> TODO("Not supported yet") + "Communication" -> TODO("Not supported yet") + "CommunicationRequest" -> TODO("Not supported yet") + else -> TODO("Not a valid request resource") + } + } + } + + /** + * Invokes the respective [RequestResourceManager] to create new request resources as per the + * proposed [CarePlan] + * + * @param resourceList List of request resources to be created + * @param requestResourceConfigs Application-specific configurations to be applied on the created + * request resources + */ + private suspend fun createProposedRequestResources(resourceList: List): List { + val createdRequestResources = ArrayList() + for (resource in resourceList) { + when (resource.fhirType()) { + "Task" -> { + defaultRepository.create(true, resource) + createdRequestResources.add(resource) + } + "ServiceRequest" -> TODO("Not supported yet") + "MedicationRequest" -> TODO("Not supported yet") + "SupplyRequest" -> TODO("Not supported yet") + "Procedure" -> TODO("Not supported yet") + "DiagnosticReport" -> TODO("Not supported yet") + "Communication" -> TODO("Not supported yet") + "CommunicationRequest" -> TODO("Not supported yet") + "RequestGroup" -> {} + else -> TODO("Not a valid request resource") + } + } + return createdRequestResources + } + + /** + * Accept the proposed [CarePlan] and create the proposed request resources as per the + * configurations + * + * @param proposedCarePlan Proposed [CarePlan] generated when $apply is run on a [PlanDefinition] + * @param carePlanOfRecord CarePlan of record for a [Patient] which needs to be updated with the + * new request resources created as per the proposed CarePlan + * @param requestResourceConfigs Application-specific configurations to be applied on the created + * request resources + */ + private suspend fun acceptCarePlan( + proposedCarePlan: CarePlan, + carePlanOfRecord: CarePlan, + ) { + val resourceList = createProposedRequestResources(proposedCarePlan.contained) + addRequestResourcesToCarePlanOfRecord(carePlanOfRecord, resourceList) + } + + /** Map [Task] status to [CarePlan] status */ + fun mapRequestResourceStatusToCarePlanStatus( + resource: Task, + ): CarePlan.CarePlanActivityStatus { + // Refer: http://hl7.org/fhir/R4/valueset-care-plan-activity-status.html for some mapping + // guidelines + return when (resource.status) { + Task.TaskStatus.ACCEPTED -> CarePlan.CarePlanActivityStatus.SCHEDULED + Task.TaskStatus.DRAFT -> CarePlan.CarePlanActivityStatus.NOTSTARTED + Task.TaskStatus.REQUESTED -> CarePlan.CarePlanActivityStatus.NOTSTARTED + Task.TaskStatus.RECEIVED -> CarePlan.CarePlanActivityStatus.NOTSTARTED + Task.TaskStatus.REJECTED -> CarePlan.CarePlanActivityStatus.STOPPED + Task.TaskStatus.READY -> CarePlan.CarePlanActivityStatus.NOTSTARTED + Task.TaskStatus.CANCELLED -> CarePlan.CarePlanActivityStatus.CANCELLED + Task.TaskStatus.INPROGRESS -> CarePlan.CarePlanActivityStatus.INPROGRESS + Task.TaskStatus.ONHOLD -> CarePlan.CarePlanActivityStatus.ONHOLD + Task.TaskStatus.FAILED -> CarePlan.CarePlanActivityStatus.STOPPED + Task.TaskStatus.COMPLETED -> CarePlan.CarePlanActivityStatus.COMPLETED + Task.TaskStatus.ENTEREDINERROR -> CarePlan.CarePlanActivityStatus.ENTEREDINERROR + Task.TaskStatus.NULL -> CarePlan.CarePlanActivityStatus.NULL + else -> CarePlan.CarePlanActivityStatus.NULL + } + } + + private inline fun getPrivateProperty(property: String, obj: T): Any? { + return T::class + .declaredMemberProperties + .find { it.name == property }!! + .apply { isAccessible = true } + .get(obj) + } + + inner class R4PlanDefinitionProcessor + constructor( + fhirContext: FhirContext, + fhirDal: FhirDal, + libraryProcessor: LibraryProcessor, + expressionEvaluator: ExpressionEvaluator, + activityDefinitionProcessor: ActivityDefinitionProcessor, + operationParametersParser: OperationParametersParser, + ) : + PlanDefinitionProcessor( + fhirContext, + fhirDal, + libraryProcessor, + expressionEvaluator, + activityDefinitionProcessor, + operationParametersParser, + ) { + override fun resolveDynamicValue( + language: String?, + expression: String?, + path: String?, + altLanguage: String?, + altExpression: String?, + altPath: String?, + libraryUrl: String?, + resource: IBaseResource?, + params: IBaseParameters?, + ) { + // no need to add dynamic value in RequestGroup resource + } + } +} diff --git a/android/engine/src/test/java/org/smartregister/fhircore/engine/task/FhirCarePlanGeneratorTest.kt b/android/engine/src/test/java/org/smartregister/fhircore/engine/task/FhirCarePlanGeneratorTest.kt index 5a9a5773b6..795b7f6b40 100644 --- a/android/engine/src/test/java/org/smartregister/fhircore/engine/task/FhirCarePlanGeneratorTest.kt +++ b/android/engine/src/test/java/org/smartregister/fhircore/engine/task/FhirCarePlanGeneratorTest.kt @@ -46,6 +46,7 @@ import java.util.Date import java.util.UUID import javax.inject.Inject import kotlin.time.Duration.Companion.seconds +import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.runBlocking import kotlinx.coroutines.test.runTest @@ -64,6 +65,7 @@ import org.hl7.fhir.r4.model.Encounter import org.hl7.fhir.r4.model.Expression import org.hl7.fhir.r4.model.Group import org.hl7.fhir.r4.model.Immunization +import org.hl7.fhir.r4.model.Library import org.hl7.fhir.r4.model.Patient import org.hl7.fhir.r4.model.Period import org.hl7.fhir.r4.model.PlanDefinition @@ -124,6 +126,8 @@ class FhirCarePlanGeneratorTest : RobolectricTest() { @Inject lateinit var transformSupportServices: TransformSupportServices + @Inject lateinit var workflowCarePlanGenerator: WorkflowCarePlanGenerator + @Inject lateinit var fhirPathEngine: FHIRPathEngine @Inject lateinit var fhirEngine: FhirEngine @@ -162,6 +166,7 @@ class FhirCarePlanGeneratorTest : RobolectricTest() { fhirPathEngine = fhirPathEngine, defaultRepository = defaultRepository, fhirResourceUtil = fhirResourceUtil, + workflowCarePlanGenerator = workflowCarePlanGenerator, ) immunizationResource = @@ -2059,6 +2064,46 @@ class FhirCarePlanGeneratorTest : RobolectricTest() { assertFalse(conditionsMet) } + @Test + @ExperimentalCoroutinesApi + fun `generateOrUpdateCarePlan should generate a sample careplan using apply`(): Unit = + runBlocking(Dispatchers.IO) { + val planDefinition = + "plans/sample-request/sample_request_plan_definition.json" + .readFile() + .decodeResourceFromString() + val patient = + "plans/sample-request/sample_request_patient.json" + .readFile() + .decodeResourceFromString() + val library = + "plans/sample-request/sample_request_example-1.0.0.cql.fhir.json" + .readFile() + .decodeResourceFromString() + + fhirEngine.create(planDefinition) + fhirEngine.create(library) + fhirEngine.create(patient) + + val resourceSlot = slot() + coEvery { defaultRepository.create(any(), capture(resourceSlot)) } answers + { + runBlocking(Dispatchers.IO) { fhirEngine.create(resourceSlot.captured) } + listOf() + } + val carePlan = + fhirCarePlanGenerator.generateOrUpdateCarePlan( + planDefinition = planDefinition, + subject = patient, + generateCarePlanWithWorkflowApi = true, + )!! + + assertNotNull(carePlan) + assertNotNull(UUID.fromString(carePlan.id)) + assertEquals(planDefinition.title, carePlan.title) + assertEquals(planDefinition.description, carePlan.description) + } + data class PlanDefinitionResources( val planDefinition: PlanDefinition, val patient: Patient, diff --git a/android/engine/src/test/resources/plans/sample-request/sample_request_example-1.0.0.cql b/android/engine/src/test/resources/plans/sample-request/sample_request_example-1.0.0.cql new file mode 100644 index 0000000000..3259dfa709 --- /dev/null +++ b/android/engine/src/test/resources/plans/sample-request/sample_request_example-1.0.0.cql @@ -0,0 +1,7 @@ +library sample_request_example version '1.0.0' +using FHIR version '4.0.1' +include FHIRHelpers version '4.0.1' + +context Patient + +define "Check Sample Request": true diff --git a/android/engine/src/test/resources/plans/sample-request/sample_request_example-1.0.0.cql.fhir.json b/android/engine/src/test/resources/plans/sample-request/sample_request_example-1.0.0.cql.fhir.json new file mode 100644 index 0000000000..91abea79d8 --- /dev/null +++ b/android/engine/src/test/resources/plans/sample-request/sample_request_example-1.0.0.cql.fhir.json @@ -0,0 +1,23 @@ +{ + "resourceType": "Library", + "id": "sample_request_example-1.0.0", + "url": "http://localhost/Library/sample_request_example|1.0.0", + "version": "1.0.0", + "name": "sample_request_example", + "status": "active", + "experimental": true, + "content": [ + { + "contentType": "text/cql", + "data": "bGlicmFyeSBzYW1wbGVfcmVxdWVzdF9leGFtcGxlIHZlcnNpb24gJzEuMC4wJwp1c2luZyBGSElSIHZlcnNpb24gJzQuMC4xJwppbmNsdWRlIEZISVJIZWxwZXJzIHZlcnNpb24gJzQuMC4xJwoKY29udGV4dCBQYXRpZW50CgpkZWZpbmUgIkNoZWNrIFNhbXBsZSBSZXF1ZXN0IjogdHJ1ZQo=" + }, + { + "contentType": "application/elm+json", + "data": "{
  "library" : {
    "type" : "Library",
    "identifier" : {
      "type" : "VersionedIdentifier",
      "id" : "sample_request_example",
      "version" : "1.0.0"
    },
    "schemaIdentifier" : {
      "type" : "VersionedIdentifier",
      "id" : "urn:hl7-org:elm",
      "version" : "r1"
    },
    "usings" : {
      "type" : "Library$Usings",
      "def" : [ {
        "type" : "UsingDef",
        "localIdentifier" : "System",
        "uri" : "urn:hl7-org:elm-types:r1"
      }, {
        "type" : "UsingDef",
        "annotation" : [ {
          "type" : "Annotation",
          "s" : {
            "s" : [ {
              "name" : "{urn:hl7-org:cql-annotations:r1}s",
              "declaredType" : "org.hl7.cql_annotations.r1.Narrative",
              "scope" : "javax.xml.bind.JAXBElement$GlobalScope",
              "value" : {
                "s" : [ "", "using " ]
              },
              "nil" : false,
              "globalScope" : true,
              "typeSubstituted" : false
            }, {
              "name" : "{urn:hl7-org:cql-annotations:r1}s",
              "declaredType" : "org.hl7.cql_annotations.r1.Narrative",
              "scope" : "javax.xml.bind.JAXBElement$GlobalScope",
              "value" : {
                "s" : [ {
                  "name" : "{urn:hl7-org:cql-annotations:r1}s",
                  "declaredType" : "org.hl7.cql_annotations.r1.Narrative",
                  "scope" : "javax.xml.bind.JAXBElement$GlobalScope",
                  "value" : {
                    "s" : [ "FHIR" ]
                  },
                  "nil" : false,
                  "globalScope" : true,
                  "typeSubstituted" : false
                } ]
              },
              "nil" : false,
              "globalScope" : true,
              "typeSubstituted" : false
            }, {
              "name" : "{urn:hl7-org:cql-annotations:r1}s",
              "declaredType" : "org.hl7.cql_annotations.r1.Narrative",
              "scope" : "javax.xml.bind.JAXBElement$GlobalScope",
              "value" : {
                "s" : [ " version ", "'4.0.1'" ]
              },
              "nil" : false,
              "globalScope" : true,
              "typeSubstituted" : false
            } ],
            "r" : "1"
          }
        } ],
        "localId" : "1",
        "locator" : "2:1-2:26",
        "localIdentifier" : "FHIR",
        "uri" : "http://hl7.org/fhir",
        "version" : "4.0.1"
      } ]
    },
    "includes" : {
      "type" : "Library$Includes",
      "def" : [ {
        "type" : "IncludeDef",
        "annotation" : [ {
          "type" : "Annotation",
          "s" : {
            "s" : [ {
              "name" : "{urn:hl7-org:cql-annotations:r1}s",
              "declaredType" : "org.hl7.cql_annotations.r1.Narrative",
              "scope" : "javax.xml.bind.JAXBElement$GlobalScope",
              "value" : {
                "s" : [ "", "include " ]
              },
              "nil" : false,
              "globalScope" : true,
              "typeSubstituted" : false
            }, {
              "name" : "{urn:hl7-org:cql-annotations:r1}s",
              "declaredType" : "org.hl7.cql_annotations.r1.Narrative",
              "scope" : "javax.xml.bind.JAXBElement$GlobalScope",
              "value" : {
                "s" : [ {
                  "name" : "{urn:hl7-org:cql-annotations:r1}s",
                  "declaredType" : "org.hl7.cql_annotations.r1.Narrative",
                  "scope" : "javax.xml.bind.JAXBElement$GlobalScope",
                  "value" : {
                    "s" : [ "FHIRHelpers" ]
                  },
                  "nil" : false,
                  "globalScope" : true,
                  "typeSubstituted" : false
                } ]
              },
              "nil" : false,
              "globalScope" : true,
              "typeSubstituted" : false
            }, {
              "name" : "{urn:hl7-org:cql-annotations:r1}s",
              "declaredType" : "org.hl7.cql_annotations.r1.Narrative",
              "scope" : "javax.xml.bind.JAXBElement$GlobalScope",
              "value" : {
                "s" : [ " version ", "'4.0.1'" ]
              },
              "nil" : false,
              "globalScope" : true,
              "typeSubstituted" : false
            } ],
            "r" : "2"
          }
        } ],
        "localId" : "2",
        "locator" : "3:1-3:35",
        "localIdentifier" : "FHIRHelpers",
        "path" : "FHIRHelpers",
        "version" : "4.0.1"
      } ]
    },
    "contexts" : {
      "type" : "Library$Contexts",
      "def" : [ {
        "type" : "ContextDef",
        "locator" : "5:1-5:15",
        "name" : "Patient"
      } ]
    },
    "statements" : {
      "type" : "Library$Statements",
      "def" : [ {
        "type" : "ExpressionDef",
        "expression" : {
          "type" : "SingletonFrom",
          "operand" : {
            "type" : "Retrieve",
            "locator" : "5:1-5:15",
            "dataType" : "{http://hl7.org/fhir}Patient",
            "templateId" : "http://hl7.org/fhir/StructureDefinition/Patient"
          }
        },
        "locator" : "5:1-5:15",
        "name" : "Patient",
        "context" : "Patient"
      }, {
        "type" : "ExpressionDef",
        "expression" : {
          "type" : "Literal",
          "localId" : "3",
          "locator" : "7:32-7:35",
          "valueType" : "{urn:hl7-org:elm-types:r1}Boolean",
          "value" : "true"
        },
        "annotation" : [ {
          "type" : "Annotation",
          "s" : {
            "s" : [ {
              "name" : "{urn:hl7-org:cql-annotations:r1}s",
              "declaredType" : "org.hl7.cql_annotations.r1.Narrative",
              "scope" : "javax.xml.bind.JAXBElement$GlobalScope",
              "value" : {
                "s" : [ "", "define ", "\"Check Sample Request\"", ": ", "true" ],
                "r" : "3"
              },
              "nil" : false,
              "globalScope" : true,
              "typeSubstituted" : false
            } ],
            "r" : "4"
          }
        } ],
        "localId" : "4",
        "locator" : "7:1-7:35",
        "name" : "Check Sample Request",
        "context" : "Patient",
        "accessLevel" : "Public"
      } ]
    },
    "annotation" : [ {
      "type" : "CqlToElmInfo",
      "translatorOptions" : "EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion"
    }, {
      "type" : "Annotation",
      "s" : {
        "s" : [ {
          "name" : "{urn:hl7-org:cql-annotations:r1}s",
          "declaredType" : "org.hl7.cql_annotations.r1.Narrative",
          "scope" : "javax.xml.bind.JAXBElement$GlobalScope",
          "value" : {
            "s" : [ "", "library sample_request_example version '1.0.0'" ]
          },
          "nil" : false,
          "globalScope" : true,
          "typeSubstituted" : false
        } ],
        "r" : "4"
      }
    } ]
  }
}" + }, + { + "contentType": "application/elm+xml", + "data": "<?xml version='1.1' encoding='UTF-8'?>
<Library type="Library">
  <wstxns1:identifier xmlns:wstxns1="urn:hl7-org:elm:r1" wstxns1:type="VersionedIdentifier" id="sample_request_example" version="1.0.0"/>
  <wstxns2:schemaIdentifier xmlns:wstxns2="urn:hl7-org:elm:r1" wstxns2:type="VersionedIdentifier" id="urn:hl7-org:elm" version="r1"/>
  <wstxns3:usings xmlns:wstxns3="urn:hl7-org:elm:r1" wstxns3:type="Library$Usings">
    <wstxns3:def>
      <wstxns3:def wstxns3:type="UsingDef" localIdentifier="System" uri="urn:hl7-org:elm-types:r1"/>
      <wstxns3:def wstxns3:type="UsingDef" localId="1" locator="2:1-2:26" localIdentifier="FHIR" uri="http://hl7.org/fhir" version="4.0.1">
        <wstxns3:annotation>
          <wstxns3:annotation wstxns3:type="Annotation">
            <wstxns4:s xmlns:wstxns4="urn:hl7-org:cql-annotations:r1" r="1">
              <s>
                <s>
                  <name>{urn:hl7-org:cql-annotations:r1}s</name>
                  <declaredType>org.hl7.cql_annotations.r1.Narrative</declaredType>
                  <scope>javax.xml.bind.JAXBElement$GlobalScope</scope>
                  <value>
                    <s>
                      <s></s>
                      <s>using </s>
                    </s>
                  </value>
                  <nil>false</nil>
                  <globalScope>true</globalScope>
                  <typeSubstituted>false</typeSubstituted>
                </s>
                <s>
                  <name>{urn:hl7-org:cql-annotations:r1}s</name>
                  <declaredType>org.hl7.cql_annotations.r1.Narrative</declaredType>
                  <scope>javax.xml.bind.JAXBElement$GlobalScope</scope>
                  <value>
                    <s>
                      <s>
                        <name>{urn:hl7-org:cql-annotations:r1}s</name>
                        <declaredType>org.hl7.cql_annotations.r1.Narrative</declaredType>
                        <scope>javax.xml.bind.JAXBElement$GlobalScope</scope>
                        <value>
                          <s>
                            <s>FHIR</s>
                          </s>
                        </value>
                        <nil>false</nil>
                        <globalScope>true</globalScope>
                        <typeSubstituted>false</typeSubstituted>
                      </s>
                    </s>
                  </value>
                  <nil>false</nil>
                  <globalScope>true</globalScope>
                  <typeSubstituted>false</typeSubstituted>
                </s>
                <s>
                  <name>{urn:hl7-org:cql-annotations:r1}s</name>
                  <declaredType>org.hl7.cql_annotations.r1.Narrative</declaredType>
                  <scope>javax.xml.bind.JAXBElement$GlobalScope</scope>
                  <value>
                    <s>
                      <s> version </s>
                      <s>'4.0.1'</s>
                    </s>
                  </value>
                  <nil>false</nil>
                  <globalScope>true</globalScope>
                  <typeSubstituted>false</typeSubstituted>
                </s>
              </s>
            </wstxns4:s>
          </wstxns3:annotation>
        </wstxns3:annotation>
      </wstxns3:def>
    </wstxns3:def>
  </wstxns3:usings>
  <wstxns5:includes xmlns:wstxns5="urn:hl7-org:elm:r1" wstxns5:type="Library$Includes">
    <wstxns5:def>
      <wstxns5:def wstxns5:type="IncludeDef" localId="2" locator="3:1-3:35" localIdentifier="FHIRHelpers" path="FHIRHelpers" version="4.0.1">
        <wstxns5:annotation>
          <wstxns5:annotation wstxns5:type="Annotation">
            <wstxns6:s xmlns:wstxns6="urn:hl7-org:cql-annotations:r1" r="2">
              <s>
                <s>
                  <name>{urn:hl7-org:cql-annotations:r1}s</name>
                  <declaredType>org.hl7.cql_annotations.r1.Narrative</declaredType>
                  <scope>javax.xml.bind.JAXBElement$GlobalScope</scope>
                  <value>
                    <s>
                      <s></s>
                      <s>include </s>
                    </s>
                  </value>
                  <nil>false</nil>
                  <globalScope>true</globalScope>
                  <typeSubstituted>false</typeSubstituted>
                </s>
                <s>
                  <name>{urn:hl7-org:cql-annotations:r1}s</name>
                  <declaredType>org.hl7.cql_annotations.r1.Narrative</declaredType>
                  <scope>javax.xml.bind.JAXBElement$GlobalScope</scope>
                  <value>
                    <s>
                      <s>
                        <name>{urn:hl7-org:cql-annotations:r1}s</name>
                        <declaredType>org.hl7.cql_annotations.r1.Narrative</declaredType>
                        <scope>javax.xml.bind.JAXBElement$GlobalScope</scope>
                        <value>
                          <s>
                            <s>FHIRHelpers</s>
                          </s>
                        </value>
                        <nil>false</nil>
                        <globalScope>true</globalScope>
                        <typeSubstituted>false</typeSubstituted>
                      </s>
                    </s>
                  </value>
                  <nil>false</nil>
                  <globalScope>true</globalScope>
                  <typeSubstituted>false</typeSubstituted>
                </s>
                <s>
                  <name>{urn:hl7-org:cql-annotations:r1}s</name>
                  <declaredType>org.hl7.cql_annotations.r1.Narrative</declaredType>
                  <scope>javax.xml.bind.JAXBElement$GlobalScope</scope>
                  <value>
                    <s>
                      <s> version </s>
                      <s>'4.0.1'</s>
                    </s>
                  </value>
                  <nil>false</nil>
                  <globalScope>true</globalScope>
                  <typeSubstituted>false</typeSubstituted>
                </s>
              </s>
            </wstxns6:s>
          </wstxns5:annotation>
        </wstxns5:annotation>
      </wstxns5:def>
    </wstxns5:def>
  </wstxns5:includes>
  <wstxns7:contexts xmlns:wstxns7="urn:hl7-org:elm:r1" wstxns7:type="Library$Contexts">
    <wstxns7:def>
      <wstxns7:def wstxns7:type="ContextDef" locator="5:1-5:15" name="Patient"/>
    </wstxns7:def>
  </wstxns7:contexts>
  <wstxns8:statements xmlns:wstxns8="urn:hl7-org:elm:r1" wstxns8:type="Library$Statements">
    <wstxns8:def>
      <wstxns8:def wstxns8:type="ExpressionDef" locator="5:1-5:15" name="Patient" context="Patient">
        <wstxns8:expression wstxns8:type="SingletonFrom">
          <wstxns8:operand wstxns8:type="Retrieve" locator="5:1-5:15" dataType="{http://hl7.org/fhir}Patient" templateId="http://hl7.org/fhir/StructureDefinition/Patient"/>
        </wstxns8:expression>
      </wstxns8:def>
      <wstxns8:def wstxns8:type="ExpressionDef" localId="4" locator="7:1-7:35" name="Check Sample Request" context="Patient" accessLevel="Public">
        <wstxns8:expression wstxns8:type="Literal" localId="3" locator="7:32-7:35" valueType="{urn:hl7-org:elm-types:r1}Boolean" value="true"/>
        <wstxns8:annotation>
          <wstxns8:annotation wstxns8:type="Annotation">
            <wstxns9:s xmlns:wstxns9="urn:hl7-org:cql-annotations:r1" r="4">
              <s>
                <s>
                  <name>{urn:hl7-org:cql-annotations:r1}s</name>
                  <declaredType>org.hl7.cql_annotations.r1.Narrative</declaredType>
                  <scope>javax.xml.bind.JAXBElement$GlobalScope</scope>
                  <value r="3">
                    <s>
                      <s></s>
                      <s>define </s>
                      <s>"Check Sample Request"</s>
                      <s>: </s>
                      <s>true</s>
                    </s>
                  </value>
                  <nil>false</nil>
                  <globalScope>true</globalScope>
                  <typeSubstituted>false</typeSubstituted>
                </s>
              </s>
            </wstxns9:s>
          </wstxns8:annotation>
        </wstxns8:annotation>
      </wstxns8:def>
    </wstxns8:def>
  </wstxns8:statements>
  <wstxns10:annotation xmlns:wstxns10="urn:hl7-org:elm:r1">
    <wstxns10:annotation wstxns10:type="CqlToElmInfo" translatorOptions="EnableAnnotations,EnableLocators,DisableListDemotion,DisableListPromotion"/>
    <wstxns10:annotation wstxns10:type="Annotation">
      <wstxns11:s xmlns:wstxns11="urn:hl7-org:cql-annotations:r1" r="4">
        <s>
          <s>
            <name>{urn:hl7-org:cql-annotations:r1}s</name>
            <declaredType>org.hl7.cql_annotations.r1.Narrative</declaredType>
            <scope>javax.xml.bind.JAXBElement$GlobalScope</scope>
            <value>
              <s>
                <s></s>
                <s>library sample_request_example version '1.0.0'</s>
              </s>
            </value>
            <nil>false</nil>
            <globalScope>true</globalScope>
            <typeSubstituted>false</typeSubstituted>
          </s>
        </s>
      </wstxns11:s>
    </wstxns10:annotation>
  </wstxns10:annotation>
</Library>
" + } + ] +} \ No newline at end of file diff --git a/android/engine/src/test/resources/plans/sample-request/sample_request_patient.json b/android/engine/src/test/resources/plans/sample-request/sample_request_patient.json new file mode 100644 index 0000000000..5aa0cf38fc --- /dev/null +++ b/android/engine/src/test/resources/plans/sample-request/sample_request_patient.json @@ -0,0 +1,15 @@ +{ + "resourceType": "Patient", + "id": "Patient-Example", + "active": true, + "name": [ + { + "family": "Hadi", + "given": [ + "Bareera" + ] + } + ], + "gender": "female", + "birthDate": "1999-01-14" +} diff --git a/android/engine/src/test/resources/plans/sample-request/sample_request_plan_definition.json b/android/engine/src/test/resources/plans/sample-request/sample_request_plan_definition.json new file mode 100644 index 0000000000..883826b2ba --- /dev/null +++ b/android/engine/src/test/resources/plans/sample-request/sample_request_plan_definition.json @@ -0,0 +1,148 @@ +{ + "resourceType": "PlanDefinition", + "meta": { + "versionId": "1", + "lastUpdated": "2022-06-20T22:30:39.217+00:00" + }, + "id" : "SampleRequest-Example", + "url" : "http://localhost/PlanDefinition/SampleRequest-Example", + "title" : "This example illustrates a medication request", + "status" : "active", + "contained": [ + { + "resourceType" : "ActivityDefinition", + "id" : "SampleRequest-1", + "url" : "http://localhost/ActivityDefinition/SampleRequest-1", + "status": "active", + "kind" : "Task", + "productCodeableConcept" : { + "text" : "Sample 1" + } + } + ], + "action": [ + { + "id": "sample-action-1", + "title" : "Administer Medication 1", + "prefix": "1", + "priority": "routine", + "dynamicValue": [ + { + "path": "title", + "expression": { + "language": "text/fhirpath", + "expression": "%rootResource.title" + } + }, + { + "path": "description", + "expression": { + "language": "text/fhirpath", + "expression": "%rootResource.description" + } + }, + { + "path": "instantiatesCanonical", + "expression": { + "language": "text/fhirpath", + "expression": "%rootResource.id.replaceMatches('/_history/.*', '')" + } + }, + { + "path": "status", + "expression": { + "language": "text/fhirpath", + "expression": "'active'" + } + }, + { + "path": "intent", + "expression": { + "language": "text/fhirpath", + "expression": "'plan'" + } + }, + { + "path": "created", + "expression": { + "language": "text/fhirpath", + "expression": "now()" + } + }, + { + "path": "subject", + "expression": { + "language": "text/fhirpath", + "expression": "%resource.entry.where(resource is QuestionnaireResponse).resource.subject" + } + }, + { + "path": "author", + "expression": { + "language": "text/fhirpath", + "expression": "$this.generalPractitioner.first()" + } + }, + { + "path": "period.start", + "expression": { + "language": "text/fhirpath", + "expression": "%resource.entry.where(resource is QuestionnaireResponse).resource.descendants().where(linkId='245679f2-6172-456e-8ff3-425f5cea3243').answer.value" + } + }, + { + "path": "period.end", + "expression": { + "language": "text/fhirpath", + "expression": "%resource.entry.where(resource is QuestionnaireResponse).resource.descendants().where(linkId='245679f2-6172-456e-8ff3-425f5cea3243').answer.value + 9 'months'" + } + }, + { + "path": "activity.detail.kind", + "expression": { + "language": "text/fhirpath", + "expression": "'Task'" + } + }, + { + "path": "activity.detail.status", + "expression": { + "language": "text/fhirpath", + "expression": "'in-progress'" + } + }, + { + "path": "activity.detail.description", + "expression": { + "language": "text/fhirpath", + "expression": "'This action will assess careplan on registration to init careplan'" + } + }, + { + "path": "activity.detail.performer", + "expression": { + "language": "text/fhirpath", + "expression": "$this.generalPractitioner.first()" + } + } + ] + }, + { + "id": "sample-action-2", + "title": "Administer Medication 1", + "prefix": "1", + "priority": "routine", + "condition": [ + { + "kind": "applicability", + "expression": { + "language": "text/cql-identifier", + "expression": "Check Sample Request" + } + } + ], + "definitionCanonical": "#SampleRequest-1" + } + ], + "library": [ "http://localhost/Library/sample_request_example|1.0.0" ] +} \ No newline at end of file diff --git a/android/quest/src/main/java/org/smartregister/fhircore/quest/ui/questionnaire/QuestionnaireViewModel.kt b/android/quest/src/main/java/org/smartregister/fhircore/quest/ui/questionnaire/QuestionnaireViewModel.kt index 500ddc83f8..429a283f01 100644 --- a/android/quest/src/main/java/org/smartregister/fhircore/quest/ui/questionnaire/QuestionnaireViewModel.kt +++ b/android/quest/src/main/java/org/smartregister/fhircore/quest/ui/questionnaire/QuestionnaireViewModel.kt @@ -623,6 +623,7 @@ constructor( planDefinitionId = planId, subject = subject, data = bundle, + generateCarePlanWithWorkflowApi = questionnaireConfig.generateCarePlanWithWorkflowApi, ) } .onFailure { Timber.e(it) }