[MWCore] Support P2P

android/deps.gradle

@@ -3,12 +3,12 @@
 // This file is referenced by the project-level build.gradle file.
 // Entries in each section of this file should be sorted alphabetically.
 def sdk_versions = [:]
-sdk_versions.compile_sdk = 33
+sdk_versions.compile_sdk = 34
 sdk_versions.min_sdk = 26
-sdk_versions.target_sdk = 33
+sdk_versions.target_sdk = 34
 ext.sdk_versions = sdk_versions
 
-def build_tool_version = '30.0.3'
+def build_tool_version = '34.0.0'
 ext.build_tool_version = build_tool_version
 
 def versions = [:]

android/engine/build.gradle

@@ -179,7 +179,7 @@ dependencies {
     implementation "androidx.datastore:datastore-preferences:1.0.0"
 
     // P2P dependency
-    implementation('org.smartregister:p2p-lib:0.3.0-SNAPSHOT')
+    api('org.smartregister:p2p-lib:0.6.8-SNAPSHOT')
 
     //Configure Jetpack Compose
     def composeVersion = versions.compose

android/engine/src/main/assets/configs/default/config_app_feature.json

@@ -37,6 +37,11 @@
         "HOUSEHOLD_VISITS",
         "REMOVE_HOUSEHOLD_MEMBER"
       ]
+    },
+    {
+      "feature": "DeviceToDeviceSync",
+      "settings": {},
+      "active": true
     }
   ]
 }

android/engine/src/main/assets/configs/default/config_application.json

@@ -6,6 +6,19 @@
     "en",
     "sw"
   ],
+  "deviceToDeviceSync": {
+    "resourcesToSync": [
+      "Group",
+      "Patient",
+      "CarePlan",
+      "Task",
+      "Encounter",
+      "Observation",
+      "Condition",
+      "Questionnaire",
+      "QuestionnaireResponse"
+    ]
+  },
   "applicationName": "Sample App",
   "appLogoIconResourceFile": "ic_launcher",
   "count": "100",

android/engine/src/main/java/org/smartregister/fhircore/engine/configuration/app/ApplicationConfiguration.kt

@@ -29,6 +29,7 @@ data class ApplicationConfiguration(
   var theme: String = "",
   var languages: List<String> = listOf("en"),
   var syncInterval: Long = 30,
+  val deviceToDeviceSync: DeviceToDeviceSyncConfig? = null,
   var scheduleDefaultPlanWorker: Boolean = true,
   var applicationName: String = "",
   var appLogoIconResourceFile: String = "ic_default_logo",

android/engine/src/main/java/org/smartregister/fhircore/engine/configuration/app/DeviceToDeviceSyncConfig.kt

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2021 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.configuration.app
+
+import kotlinx.serialization.Serializable
+
+@Serializable data class DeviceToDeviceSyncConfig(val resourcesToSync: List<String>? = null)

android/engine/src/main/java/org/smartregister/fhircore/engine/p2p/dao/BaseP2PTransferDao.kt

@@ -20,118 +20,126 @@
 import ca.uhn.fhir.context.FhirVersionEnum
 import ca.uhn.fhir.parser.IParser
 import ca.uhn.fhir.rest.gclient.DateClientParam
+import ca.uhn.fhir.rest.gclient.StringClientParam
 import ca.uhn.fhir.rest.param.ParamPrefixEnum
 import com.google.android.fhir.FhirEngine
-import com.google.android.fhir.db.ResourceNotFoundException
-import com.google.android.fhir.get
-import com.google.android.fhir.logicalId
+import com.google.android.fhir.SearchResult
+import com.google.android.fhir.search.Order
 import com.google.android.fhir.search.Search
-import com.google.android.fhir.search.search
+import com.google.android.fhir.sync.SyncDataParams
 import java.util.Date
 import java.util.TreeSet
 import kotlinx.coroutines.withContext
 import org.hl7.fhir.r4.model.DateTimeType
-import org.hl7.fhir.r4.model.Encounter
-import org.hl7.fhir.r4.model.Group
-import org.hl7.fhir.r4.model.Observation
-import org.hl7.fhir.r4.model.Patient
-import org.hl7.fhir.r4.model.Questionnaire
-import org.hl7.fhir.r4.model.QuestionnaireResponse
 import org.hl7.fhir.r4.model.Resource
 import org.hl7.fhir.r4.model.ResourceType
+import org.smartregister.fhircore.engine.configuration.ConfigurationRegistry
+import org.smartregister.fhircore.engine.configuration.app.AppConfigClassification
+import org.smartregister.fhircore.engine.configuration.app.ApplicationConfiguration
 import org.smartregister.fhircore.engine.util.DispatcherProvider
-import org.smartregister.fhircore.engine.util.extension.generateMissingId
-import org.smartregister.fhircore.engine.util.extension.updateFrom
-import org.smartregister.fhircore.engine.util.extension.updateLastUpdated
+import org.smartregister.fhircore.engine.util.extension.isValidResourceType
+import org.smartregister.fhircore.engine.util.extension.resourceClassType
+import org.smartregister.p2p.model.RecordCount
 import org.smartregister.p2p.sync.DataType
 
 open class BaseP2PTransferDao
-constructor(open val fhirEngine: FhirEngine, open val dispatcherProvider: DispatcherProvider) {
+constructor(
+  open val fhirEngine: FhirEngine,
+  open val dispatcherProvider: DispatcherProvider,
+  open val configurationRegistry: ConfigurationRegistry,
+) {
 
   protected val jsonParser: IParser = FhirContext.forCached(FhirVersionEnum.R4).newJsonParser()
 
-  open fun getDataTypes(): TreeSet<DataType> =
+  open fun getDataTypes(): TreeSet<DataType> {
+    val appRegistry =
+      configurationRegistry.retrieveConfiguration<ApplicationConfiguration>(
+        AppConfigClassification.APPLICATION
+      )
+    val deviceToDeviceSyncConfigs = appRegistry.deviceToDeviceSync
+
+    return if (deviceToDeviceSyncConfigs?.resourcesToSync != null &&
+        deviceToDeviceSyncConfigs.resourcesToSync.isNotEmpty()
+    ) {
+      getDynamicDataTypes(deviceToDeviceSyncConfigs.resourcesToSync)
+    } else {
+      getDefaultDataTypes()
+    }
+  }
+
+  open fun getDefaultDataTypes(): TreeSet<DataType> =
     TreeSet<DataType>(
       listOf(
         ResourceType.Group,
         ResourceType.Patient,
         ResourceType.Questionnaire,
         ResourceType.QuestionnaireResponse,
         ResourceType.Observation,
-        ResourceType.Encounter
+        ResourceType.Encounter,
       )
         .mapIndexed { index, resourceType ->
           DataType(name = resourceType.name, DataType.Filetype.JSON, index)
-        }
+        },
     )
 
-  suspend fun <R : Resource> addOrUpdate(resource: R) {
-    return withContext(dispatcherProvider.io()) {
-      resource.updateLastUpdated()
-      try {
-        fhirEngine.get(resource.resourceType, resource.logicalId).run {
-          fhirEngine.update(updateFrom(resource))
-        }
-      } catch (resourceNotFoundException: ResourceNotFoundException) {
-        resource.generateMissingId()
-        fhirEngine.create(resource)
-      }
-    }
-  }
+  open fun getDynamicDataTypes(resourceList: List<String>): TreeSet<DataType> =
+    TreeSet<DataType>(
+      resourceList.filter { isValidResourceType(it) }.mapIndexed { index, resource ->
+        DataType(name = resource, DataType.Filetype.JSON, index)
+      },
+    )
 
   suspend fun loadResources(
     lastRecordUpdatedAt: Long,
     batchSize: Int,
-    classType: Class<out Resource>
-  ): List<Resource> {
+    offset: Int,
+    classType: Class<out Resource>,
+  ): List<SearchResult<Resource>> {
     return withContext(dispatcherProvider.io()) {
-      // TODO FIX search order by _lastUpdated; SearchQuery no longer allowed in search API
-
-      /*  val searchQuery =
-        SearchQuery(
-          """
-      SELECT a.serializedResource, b.index_to
-      FROM ResourceEntity a
-      LEFT JOIN DateTimeIndexEntity b
-      ON a.resourceType = b.resourceType AND a.resourceId = b.resourceId AND b.index_name = '_lastUpdated'
-      WHERE a.resourceType = '${classType.newInstance().resourceType}'
-      AND a.resourceId IN (
-      SELECT resourceId FROM DateTimeIndexEntity
-      WHERE resourceType = '${classType.newInstance().resourceType}' AND index_name = '_lastUpdated' AND index_to > ?
-      )
-      ORDER BY b.index_from ASC
-      LIMIT ?
-          """.trimIndent(),
-          listOf(lastRecordUpdatedAt, batchSize)
-        )
-
-      fhirEngine.search(searchQuery)*/
-
       val search =
         Search(type = classType.newInstance().resourceType).apply {
           filter(
-            DateClientParam("_lastUpdated"),
+            DateClientParam(SyncDataParams.LAST_UPDATED_KEY),
             {
               value = of(DateTimeType(Date(lastRecordUpdatedAt)))
-              prefix = ParamPrefixEnum.GREATERTHAN
-            }
+              prefix = ParamPrefixEnum.GREATERTHAN_OR_EQUALS
+            },
           )
 
-          // sort(StringClientParam("_lastUpdated"), Order.ASCENDING)
+          sort(StringClientParam(SyncDataParams.LAST_UPDATED_KEY), Order.ASCENDING)
           count = batchSize
+          from = offset
         }
-      fhirEngine.search<Resource>(search).map { it.resource }
+      fhirEngine.search(search)
+    }
+  }
+
+  suspend fun countTotalRecordsForSync(highestRecordIdMap: HashMap<String, Long>): RecordCount {
+    var totalRecordCount: Long = 0
+    val resourceCountMap: HashMap<String, Long> = HashMap()
+
+    getDataTypes().forEach {
+      it.name.resourceClassType().let { classType ->
+        val lastRecordId = highestRecordIdMap[it.name] ?: 0L
+        val searchCount = getSearchObjectForCount(lastRecordId, classType)
+        val resourceCount = fhirEngine.count(searchCount)
+        totalRecordCount += resourceCount
+        resourceCountMap[it.name] = resourceCount
+      }
     }
+
+    return RecordCount(totalRecordCount, resourceCountMap)
   }
 
-  fun resourceClassType(type: DataType) =
-    when (ResourceType.valueOf(type.name)) {
-      ResourceType.Group -> Group::class.java
-      ResourceType.Encounter -> Encounter::class.java
-      ResourceType.Observation -> Observation::class.java
-      ResourceType.Patient -> Patient::class.java
-      ResourceType.Questionnaire -> Questionnaire::class.java
-      ResourceType.QuestionnaireResponse -> QuestionnaireResponse::class.java
-      else -> null /*TODO support other resource types*/
+  fun getSearchObjectForCount(lastRecordUpdatedAt: Long, classType: Class<out Resource>): Search {
+    return Search(type = classType.newInstance().resourceType).apply {
+      filter(
+        DateClientParam(SyncDataParams.LAST_UPDATED_KEY),
+        {
+          value = of(DateTimeType(Date(lastRecordUpdatedAt)))
+          prefix = ParamPrefixEnum.GREATERTHAN_OR_EQUALS
+        },
+      )
     }
+  }
 }

android/engine/src/main/java/org/smartregister/fhircore/engine/p2p/dao/P2PReceiverTransferDao.kt

@@ -16,36 +16,42 @@
 
 package org.smartregister.fhircore.engine.p2p.dao
 
-import androidx.annotation.NonNull
 import com.google.android.fhir.FhirEngine
 import com.google.android.fhir.logicalId
 import java.util.TreeSet
 import javax.inject.Inject
 import kotlinx.coroutines.runBlocking
 import org.json.JSONArray
+import org.smartregister.fhircore.engine.configuration.ConfigurationRegistry
+import org.smartregister.fhircore.engine.data.local.DefaultRepository
 import org.smartregister.fhircore.engine.util.DispatcherProvider
+import org.smartregister.fhircore.engine.util.extension.resourceClassType
 import org.smartregister.p2p.dao.ReceiverTransferDao
 import org.smartregister.p2p.sync.DataType
 import timber.log.Timber
 
 open class P2PReceiverTransferDao
 @Inject
-constructor(fhirEngine: FhirEngine, dispatcherProvider: DispatcherProvider) :
-  BaseP2PTransferDao(fhirEngine, dispatcherProvider), ReceiverTransferDao {
+constructor(
+  fhirEngine: FhirEngine,
+  dispatcherProvider: DispatcherProvider,
+  configurationRegistry: ConfigurationRegistry,
+  val defaultRepository: DefaultRepository,
+) : BaseP2PTransferDao(fhirEngine, dispatcherProvider, configurationRegistry), ReceiverTransferDao {
 
   override fun getP2PDataTypes(): TreeSet<DataType> = getDataTypes()
 
-  override fun receiveJson(@NonNull type: DataType, @NonNull jsonArray: JSONArray): Long {
+  override fun receiveJson(type: DataType, jsonArray: JSONArray): Long {
     var maxLastUpdated = 0L
-    Timber.e("saving resources from base dai")
+    Timber.i("saving resources from base dai ${type.name} -> ${jsonArray.length()}")
     (0 until jsonArray.length()).forEach {
       runBlocking {
         val resource =
-          jsonParser.parseResource(resourceClassType(type), jsonArray.get(it).toString())
-        addOrUpdate(resource = resource)
+          jsonParser.parseResource(type.name.resourceClassType(), jsonArray.get(it).toString())
+        val recordLastUpdated = resource.meta.lastUpdated.time
+        defaultRepository.addOrUpdate(resource = resource)
         maxLastUpdated =
-          (if (resource.meta.lastUpdated.time > maxLastUpdated) resource.meta.lastUpdated.time
-          else maxLastUpdated)
+          (if (recordLastUpdated > maxLastUpdated) recordLastUpdated else maxLastUpdated)
         Timber.e("Received ${resource.resourceType} with id = ${resource.logicalId}")
       }
     }