Remove OpenTask accounts when native added

app/src/main/java/org/tasks/data/OpenTaskDao.kt

@@ -13,11 +13,11 @@ import org.dmfs.tasks.contract.TaskContract.*
 import org.dmfs.tasks.contract.TaskContract.Properties
 import org.json.JSONObject
 import org.tasks.R
+import org.tasks.data.CaldavAccount.Companion.TYPE_OPENTASKS
 import org.tasks.data.CaldavAccount.Companion.openTaskType
 import timber.log.Timber
 import java.util.*
 import javax.inject.Inject
-import kotlin.collections.ArrayList
 
 open class OpenTaskDao @Inject constructor(
         @ApplicationContext context: Context,
@@ -29,7 +29,9 @@ open class OpenTaskDao @Inject constructor(
     val taskLists: Uri = TaskLists.getContentUri(authority)
     val properties: Uri = Properties.getContentUri(authority)
 
-    suspend fun newAccounts(): List<String> = getListsByAccount().newAccounts(caldavDao)
+    suspend fun shouldSync() =
+        caldavDao.getAccounts(TYPE_OPENTASKS).isNotEmpty() ||
+                getListsByAccount().filterActive(caldavDao).isNotEmpty()
 
     suspend fun getListsByAccount(): Map<String, List<CaldavCalendar>> =
             getLists().groupBy { it.account!! }
@@ -143,10 +145,8 @@ open class OpenTaskDao @Inject constructor(
         )
         val SUPPORTED_TYPE_FILTER = SUPPORTED_TYPES.joinToString(" OR ") { "ACCOUNT_TYPE = '$it'" }
 
-        suspend fun Map<String, List<CaldavCalendar>>.newAccounts(caldavDao: CaldavDao) =
+        suspend fun Map<String, List<CaldavCalendar>>.filterActive(caldavDao: CaldavDao) =
                 filterNot { (_, lists) -> caldavDao.anyExist(lists.map { it.url!! }) }
-                        .map { it.key }
-                        .distinct()
 
         fun String?.isDavx5(): Boolean = this?.startsWith(ACCOUNT_TYPE_DAVx5) == true
 

app/src/main/java/org/tasks/jobs/SyncOpenTasksWork.kt

@@ -11,8 +11,6 @@ import dagger.assisted.AssistedInject
 import org.tasks.LocalBroadcastManager
 import org.tasks.R
 import org.tasks.analytics.Firebase
-import org.tasks.data.CaldavAccount.Companion.TYPE_OPENTASKS
-import org.tasks.data.CaldavDao
 import org.tasks.data.OpenTaskDao
 import org.tasks.data.OpenTaskDao.Companion.SUPPORTED_TYPES
 import org.tasks.opentasks.OpenTasksSynchronizer
@@ -26,14 +24,11 @@ class SyncOpenTasksWork @AssistedInject constructor(
         localBroadcastManager: LocalBroadcastManager,
         preferences: Preferences,
         private val openTasksSynchronizer: OpenTasksSynchronizer,
-        private val caldavDao: CaldavDao,
         private val openTaskDao: OpenTaskDao
 ) : SyncWork(context, workerParams, firebase, localBroadcastManager, preferences) {
     override val syncStatus = R.string.p_sync_ongoing_opentasks
 
-    override suspend fun enabled() =
-            caldavDao.getAccounts(TYPE_OPENTASKS).isNotEmpty()
-                    || openTaskDao.newAccounts().isNotEmpty()
+    override suspend fun enabled() = openTaskDao.shouldSync()
 
     override suspend fun doSync() {
         openTasksSynchronizer.sync()

app/src/main/java/org/tasks/jobs/WorkManagerImpl.kt

@@ -28,7 +28,6 @@ import org.tasks.R
 import org.tasks.data.CaldavAccount
 import org.tasks.data.CaldavAccount.Companion.TYPE_CALDAV
 import org.tasks.data.CaldavAccount.Companion.TYPE_ETEBASE
-import org.tasks.data.CaldavAccount.Companion.TYPE_OPENTASKS
 import org.tasks.data.CaldavAccount.Companion.TYPE_TASKS
 import org.tasks.data.CaldavDao
 import org.tasks.data.GoogleTaskListDao
@@ -179,8 +178,8 @@ class WorkManagerImpl constructor(
             scheduleBackgroundSync(
                     TAG_BACKGROUND_SYNC_OPENTASKS,
                     SyncOpenTasksWork::class.java,
-                    caldavDao.getAccounts(TYPE_OPENTASKS).isNotEmpty()
-                            || openTaskDao.newAccounts().isNotEmpty())
+                    openTaskDao.shouldSync()
+            )
         }
     }
 

app/src/main/java/org/tasks/opentasks/OpenTasksSynchronizer.kt

@@ -21,10 +21,10 @@ import org.tasks.data.CaldavDao
 import org.tasks.data.CaldavTask
 import org.tasks.data.MyAndroidTask
 import org.tasks.data.OpenTaskDao
+import org.tasks.data.OpenTaskDao.Companion.filterActive
 import org.tasks.data.OpenTaskDao.Companion.isDavx5
 import org.tasks.data.OpenTaskDao.Companion.isDecSync
 import org.tasks.data.OpenTaskDao.Companion.isEteSync
-import org.tasks.data.OpenTaskDao.Companion.newAccounts
 import org.tasks.data.OpenTaskDao.Companion.toLocalCalendar
 import timber.log.Timber
 import javax.inject.Inject
@@ -43,28 +43,28 @@ class OpenTasksSynchronizer @Inject constructor(
         private val inventory: Inventory) {
 
     suspend fun sync() {
-        val lists = openTaskDao.getListsByAccount()
-        lists.newAccounts(caldavDao)
-                .filter { caldavDao.getAccountByUuid(it) == null }
-                .map {
-                    CaldavAccount().apply {
-                        name = it.split(":")[1]
-                        uuid = it
-                        accountType = CaldavAccount.TYPE_OPENTASKS
-                    }
-                }
-                .onEach { caldavDao.insert(it) }
-                .forEach {
-                    firebase.logEvent(
-                            R.string.event_sync_add_account,
-                            R.string.param_type to when {
-                                it.uuid.isDavx5() -> Constants.SYNC_TYPE_DAVX5
-                                it.uuid.isEteSync() -> Constants.SYNC_TYPE_ETESYNC_OT
-                                it.uuid.isDecSync() -> Constants.SYNC_TYPE_DECSYNC
-                                else -> throw IllegalArgumentException()
-                            }
-                    )
+        val lists = openTaskDao.getListsByAccount().filterActive(caldavDao)
+        lists.keys
+            .filter { caldavDao.getAccountByUuid(it) == null }
+            .map {
+                CaldavAccount().apply {
+                    name = it.split(":")[1]
+                    uuid = it
+                    accountType = CaldavAccount.TYPE_OPENTASKS
                 }
+            }
+            .onEach { caldavDao.insert(it) }
+            .forEach {
+                firebase.logEvent(
+                    R.string.event_sync_add_account,
+                    R.string.param_type to when {
+                        it.uuid.isDavx5() -> Constants.SYNC_TYPE_DAVX5
+                        it.uuid.isEteSync() -> Constants.SYNC_TYPE_ETESYNC_OT
+                        it.uuid.isDecSync() -> Constants.SYNC_TYPE_DECSYNC
+                        else -> throw IllegalArgumentException()
+                    }
+                )
+            }
         caldavDao.getAccounts(CaldavAccount.TYPE_OPENTASKS).forEach { account ->
             val entries = lists[account.uuid!!]
             if (entries == null) {

app/src/main/java/org/tasks/sync/SyncAdapters.kt

@@ -2,7 +2,11 @@ package org.tasks.sync
 
 import com.todoroo.astrid.data.SyncFlags
 import com.todoroo.astrid.data.Task
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.async
+import kotlinx.coroutines.launch
 import org.tasks.LocalBroadcastManager
 import org.tasks.R
 import org.tasks.data.CaldavAccount.Companion.TYPE_CALDAV
@@ -110,7 +114,5 @@ class SyncAdapters @Inject constructor(
 
     private suspend fun isEtebaseEnabled() = caldavDao.getAccounts(TYPE_ETEBASE).isNotEmpty()
 
-    private suspend fun isOpenTaskSyncEnabled() =
-            caldavDao.getAccounts(TYPE_OPENTASKS).isNotEmpty()
-                    || openTaskDao.newAccounts().isNotEmpty()
+    private suspend fun isOpenTaskSyncEnabled() = openTaskDao.shouldSync()
 }