Validate extracted fhir resources while in debug

android/engine/build.gradle.kts

@@ -263,6 +263,7 @@ dependencies {
   implementation(Dependencies.HapiFhir.structuresR4) { exclude(module = "junit") }
   implementation(Dependencies.HapiFhir.guavaCaching)
   implementation(Dependencies.HapiFhir.validationR4)
+  implementation(Dependencies.HapiFhir.validationR5)
   implementation(Dependencies.HapiFhir.validation) {
     exclude(module = "commons-logging")
     exclude(module = "httpclient")

android/engine/src/main/java/org/smartregister/fhircore/engine/di/FhirValidatorModule.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2021-2024 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.di
+
+import ca.uhn.fhir.context.FhirContext
+import ca.uhn.fhir.context.support.DefaultProfileValidationSupport
+import ca.uhn.fhir.context.support.IValidationSupport
+import ca.uhn.fhir.validation.FhirValidator
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+import org.hl7.fhir.common.hapi.validation.support.CommonCodeSystemsTerminologyService
+import org.hl7.fhir.common.hapi.validation.support.InMemoryTerminologyServerValidationSupport
+import org.hl7.fhir.common.hapi.validation.support.UnknownCodeSystemWarningValidationSupport
+import org.hl7.fhir.common.hapi.validation.support.ValidationSupportChain
+import org.hl7.fhir.common.hapi.validation.validator.FhirInstanceValidator
+
+@Module
+@InstallIn(SingletonComponent::class)
+class FhirValidatorModule {
+
+  @Provides
+  @Singleton
+  fun provideFhirValidator(): FhirValidator {
+    val fhirContext = FhirContext.forR4()
+
+    val validationSupportChain =
+      ValidationSupportChain(
+        DefaultProfileValidationSupport(fhirContext),
+        InMemoryTerminologyServerValidationSupport(fhirContext),
+        CommonCodeSystemsTerminologyService(fhirContext),
+        UnknownCodeSystemWarningValidationSupport(fhirContext).apply {
+          setNonExistentCodeSystemSeverity(IValidationSupport.IssueSeverity.WARNING)
+        },
+      )
+    val instanceValidator = FhirInstanceValidator(validationSupportChain)
+    instanceValidator.isAssumeValidRestReferences = true
+    instanceValidator.invalidateCaches()
+    return fhirContext.newValidator().apply { registerValidatorModule(instanceValidator) }
+  }
+}

android/engine/src/main/java/org/smartregister/fhircore/engine/util/extension/FhirValidatorExtension.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2021-2024 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.util.extension
+
+import ca.uhn.fhir.validation.FhirValidator
+import ca.uhn.fhir.validation.ResultSeverityEnum
+import ca.uhn.fhir.validation.ValidationResult
+import kotlin.coroutines.coroutineContext
+import kotlinx.coroutines.withContext
+import org.hl7.fhir.r4.model.Resource
+import org.smartregister.fhircore.engine.BuildConfig
+
+suspend fun FhirValidator.checkResourceValid(
+  vararg resource: Resource,
+  isDebug: Boolean = BuildConfig.BUILD_TYPE.contains("debug", ignoreCase = true),
+): List<ValidationResult> {
+  if (!isDebug) return emptyList()
+
+  return withContext(coroutineContext) {
+    resource.map { [email protected](it) }
+  }
+}
+
+val ValidationResult.errorMessages
+  get() = buildString {
+    for (validationMsg in
+      messages.filter { it.severity.ordinal >= ResultSeverityEnum.WARNING.ordinal }) {
+      appendLine(
+        "${validationMsg.message} - ${validationMsg.locationString} -- (${validationMsg.severity})",
+      )
+    }
+  }

android/engine/src/test/java/org/smartregister/fhircore/engine/task/FhirCarePlanGeneratorTest.kt

@@ -201,8 +201,8 @@ class FhirCarePlanGeneratorTest : RobolectricTest() {
     fhirCarePlanGenerator =
       FhirCarePlanGenerator(
         fhirEngine = fhirEngine,
-        transformSupportServices = transformSupportServices,
         fhirPathEngine = fhirPathEngine,
+        transformSupportServices = transformSupportServices,
         defaultRepository = defaultRepository,
         fhirResourceUtil = fhirResourceUtil,
         workflowCarePlanGenerator = workflowCarePlanGenerator,

android/engine/src/test/java/org/smartregister/fhircore/engine/util/extension/FhirValidatorExtensionTest.kt

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2021-2024 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.util.extension
+
+import ca.uhn.fhir.validation.FhirValidator
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.mockk.spyk
+import io.mockk.verify
+import javax.inject.Inject
+import kotlinx.coroutines.test.runTest
+import org.hl7.fhir.instance.model.api.IBaseResource
+import org.hl7.fhir.r4.model.CarePlan
+import org.hl7.fhir.r4.model.Patient
+import org.hl7.fhir.r4.model.Reference
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.smartregister.fhircore.engine.robolectric.RobolectricTest
+
+@HiltAndroidTest
+class FhirValidatorExtensionTest : RobolectricTest() {
+
+  @get:Rule var hiltRule = HiltAndroidRule(this)
+
+  @Inject lateinit var validator: FhirValidator
+
+  @Before
+  fun setUp() {
+    hiltRule.inject()
+  }
+
+  @Test
+  fun testCheckResourceValidRunsNoValidationWhenBuildTypeIsNotDebug() = runTest {
+    val basicResource = CarePlan()
+    val fhirValidatorSpy = spyk(validator)
+    val results = fhirValidatorSpy.checkResourceValid(basicResource, isDebug = false)
+    Assert.assertTrue(results.isEmpty())
+    verify(exactly = 0) { fhirValidatorSpy.validateWithResult(any<IBaseResource>()) }
+    verify(exactly = 0) { fhirValidatorSpy.validateWithResult(any<String>()) }
+  }
+
+  @Test
+  fun testCheckResourceValidValidatesResourceStructureWhenCarePlanResourceInvalid() = runTest {
+    val basicCarePlan = CarePlan()
+    val results = validator.checkResourceValid(basicCarePlan)
+    Assert.assertFalse(results.isEmpty())
+    Assert.assertTrue(
+      results.any {
+        it.errorMessages.contains(
+          "CarePlan.status: minimum required = 1, but only found 0",
+          ignoreCase = true,
+        )
+      },
+    )
+    Assert.assertTrue(
+      results.any {
+        it.errorMessages.contains(
+          "CarePlan.intent: minimum required = 1, but only found 0",
+          ignoreCase = true,
+        )
+      },
+    )
+  }
+
+  @Test
+  fun testCheckResourceValidValidatesReferenceType() = runTest {
+    val carePlan =
+      CarePlan().apply {
+        status = CarePlan.CarePlanStatus.ACTIVE
+        intent = CarePlan.CarePlanIntent.PLAN
+        subject = Reference("Task/unknown")
+      }
+    val results = validator.checkResourceValid(carePlan)
+    Assert.assertFalse(results.isEmpty())
+    Assert.assertEquals(1, results.size)
+    Assert.assertTrue(
+      results
+        .first()
+        .errorMessages
+        .contains(
+          "The type 'Task' implied by the reference URL Task/unknown is not a valid Target for this element (must be one of [Group, Patient]) - CarePlan.subject",
+          ignoreCase = true,
+        ),
+    )
+  }
+
+  @Test
+  fun testCheckResourceValidValidatesReferenceWithNoType() = runTest {
+    val carePlan =
+      CarePlan().apply {
+        status = CarePlan.CarePlanStatus.ACTIVE
+        intent = CarePlan.CarePlanIntent.PLAN
+        subject = Reference("unknown")
+      }
+    val results = validator.checkResourceValid(carePlan)
+    Assert.assertFalse(results.isEmpty())
+    Assert.assertEquals(1, results.size)
+    Assert.assertTrue(
+      results
+        .first()
+        .errorMessages
+        .contains(
+          "The syntax of the reference 'unknown' looks incorrect, and it should be checked - CarePlan.subject",
+          ignoreCase = true,
+        ),
+    )
+  }
+
+  @Test
+  fun testCheckResourceValidValidatesResourceCorrectly() = runTest {
+    val patient = Patient()
+    val carePlan =
+      CarePlan().apply {
+        status = CarePlan.CarePlanStatus.ACTIVE
+        intent = CarePlan.CarePlanIntent.PLAN
+        subject = Reference(patient)
+      }
+    val results = validator.checkResourceValid(carePlan)
+    Assert.assertFalse(results.isEmpty())
+    Assert.assertEquals(1, results.size)
+    Assert.assertTrue(results.first().errorMessages.isBlank())
+  }
+}

android/quest/src/main/java/org/smartregister/fhircore/quest/ui/questionnaire/QuestionnaireActivity.kt

@@ -39,6 +39,7 @@
 import java.io.Serializable
 import javax.inject.Inject
 import kotlinx.coroutines.launch
+import org.hl7.fhir.r4.model.IdType
 import org.hl7.fhir.r4.model.Questionnaire
 import org.hl7.fhir.r4.model.QuestionnaireResponse
 import org.hl7.fhir.r4.model.Resource
@@ -52,9 +53,11 @@
 import org.smartregister.fhircore.engine.util.extension.encodeResourceToString
 import org.smartregister.fhircore.engine.util.extension.parcelable
 import org.smartregister.fhircore.engine.util.extension.parcelableArrayList
+import org.smartregister.fhircore.engine.util.extension.referenceValue
 import org.smartregister.fhircore.engine.util.extension.showToast
 import org.smartregister.fhircore.engine.util.location.LocationUtils
 import org.smartregister.fhircore.engine.util.location.PermissionUtils
+import org.smartregister.fhircore.quest.BuildConfig
 import org.smartregister.fhircore.quest.R
 import org.smartregister.fhircore.quest.databinding.QuestionnaireActivityBinding
 import org.smartregister.fhircore.quest.util.ResourceUtils
@@ -336,26 +339,75 @@
               questionnaireConfig = questionnaireConfig,
               actionParameters = actionParameters,
               context = this@QuestionnaireActivity,
-            ) { idTypes, questionnaireResponse ->
+            ) { idTypes, questionnaireResponse, extractedValidationErrors ->
               // Dismiss progress indicator dialog, submit result then finish activity
               // TODO Ensure this dialog is dismissed even when an exception is encountered
               setProgressState(QuestionnaireProgressState.ExtractionInProgress(false))
-              setResult(
-                Activity.RESULT_OK,
-                Intent().apply {
-                  putExtra(QUESTIONNAIRE_RESPONSE, questionnaireResponse as Serializable)
-                  putExtra(QUESTIONNAIRE_SUBMISSION_EXTRACTED_RESOURCE_IDS, idTypes as Serializable)
-                  putExtra(QUESTIONNAIRE_CONFIG, questionnaireConfig as Parcelable)
-                },
-              )
-              finish()
+
+              if (BuildConfig.BUILD_TYPE.contains("debug", ignoreCase = true)) {
+                val message =
+                  if (extractedValidationErrors.isEmpty()) {
+                    "Questionnaire submitted and saved successfully with no validation errors"
+                  } else {
+                    """
+                    Questionnaire `${questionnaire?.referenceValue()}` was submitted but had the following validation errors
+
+                    ${
+                                            buildString {
+                                                extractedValidationErrors.forEach {
+                                                    appendLine("${it.key}: ")
+                                                    append(it.value)
+                                                    appendLine()
+                                                }
+                                            }
+                                        }
+                                    """
+                      .trimIndent()
+                  }
+
+                AlertDialogue.showInfoAlert(
+                  this@QuestionnaireActivity,
+                  message,
+                  "Questionnaire submitted",
+                  {
+                    it.dismiss()
+                    finishOnQuestionnaireSubmission(
+                      questionnaireResponse,
+                      idTypes,
+                      questionnaireConfig,
+                    )
+                  },
+                )
+              } else {
+                finishOnQuestionnaireSubmission(
+                  questionnaireResponse,
+                  idTypes,
+                  questionnaireConfig,
+                )
+              }
             }
           }
         }
       }
     }
   }
 
+  private fun finishOnQuestionnaireSubmission(
+    questionnaireResponse: QuestionnaireResponse,
+    idTypes: List<IdType>,
+    questionnaireConfig: QuestionnaireConfig,
+  ) {
+    setResult(
+      Activity.RESULT_OK,
+      Intent().apply {
+        putExtra(QUESTIONNAIRE_RESPONSE, questionnaireResponse as Serializable)
+        putExtra(QUESTIONNAIRE_SUBMISSION_EXTRACTED_RESOURCE_IDS, idTypes as Serializable)
+        putExtra(QUESTIONNAIRE_CONFIG, questionnaireConfig as Parcelable)
+      },
+    )
+    finish()
+  }
+
   private fun handleBackPress() {
     if (questionnaireConfig.isReadOnly()) {
       finish()