[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}")
  }
  }