Merged calendar view models

app/src/main/java/org/tasks/caldav/CaldavCalendarSettingsActivity.kt

@@ -27,10 +27,6 @@ class CaldavCalendarSettingsActivity : BaseCaldavCalendarSettingsActivity() {
 
     private val viewModel: CaldavCalendarViewModel by viewModels()
 
-    private val createCalendarViewModel: CreateCalendarViewModel by viewModels()
-    private val deleteCalendarViewModel: DeleteCalendarViewModel by viewModels()
-    private val updateCalendarViewModel: UpdateCalendarViewModel by viewModels()
-
     override val layout = R.layout.activity_caldav_calendar_settings
 
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -43,13 +39,10 @@ class CaldavCalendarSettingsActivity : BaseCaldavCalendarSettingsActivity() {
                 viewModel.error.value = null
             }
         }
-
+        viewModel.finish.observe(this) {
-        createCalendarViewModel.observe(this, this::createSuccessful, this::requestFailed)
+            setResult(RESULT_OK, it)
-        deleteCalendarViewModel.observe(this, this::onDeleted, this::requestFailed)
+            finish()
-        updateCalendarViewModel.observe(
+        }
-                this,
-                { updateCalendar() },
-                this::requestFailed)
 
         caldavCalendar?.takeIf { it.id > 0 }?.let {
             principalDao.getPrincipals(it.id).observe(this) {
@@ -81,21 +74,32 @@ class CaldavCalendarSettingsActivity : BaseCaldavCalendarSettingsActivity() {
 
     private fun removePrincipal(principal: Principal) = lifecycleScope.launch {
         try {
-            viewModel.remove(caldavAccount, caldavCalendar!!, principal)
+            viewModel.removeUser(caldavAccount, caldavCalendar!!, principal)
         } catch (e: Exception) {
             requestFailed(e)
         }
     }
 
-    override suspend fun createCalendar(caldavAccount: CaldavAccount, name: String, color: Int) =
+    override suspend fun createCalendar(caldavAccount: CaldavAccount, name: String, color: Int) {
-            createCalendarViewModel.createCalendar(caldavAccount, name, color)
+        viewModel.createCalendar(caldavAccount, name, color, selectedIcon)
+    }
 
     override suspend fun updateNameAndColor(
-            account: CaldavAccount, calendar: CaldavCalendar, name: String, color: Int) =
+            account: CaldavAccount,
-            updateCalendarViewModel.updateCalendar(account, calendar, name, color)
+            calendar: CaldavCalendar,
+            name: String,
+            color: Int
+    ) {
+        viewModel.updateCalendar(account, calendar, name, color, selectedIcon)
+    }
+
+    override suspend fun deleteCalendar(
+        caldavAccount: CaldavAccount,
+        caldavCalendar: CaldavCalendar
+    ) {
+        viewModel.deleteCalendar(caldavAccount, caldavCalendar)
+    }
 
-    override suspend fun deleteCalendar(caldavAccount: CaldavAccount, caldavCalendar: CaldavCalendar) =
-            deleteCalendarViewModel.deleteCalendar(caldavAccount, caldavCalendar)
 
     companion object {
         val CaldavAccount.canRemovePrincipal: Boolean

app/src/main/java/org/tasks/caldav/CaldavCalendarViewModel.kt

@@ -1,12 +1,20 @@
 package org.tasks.caldav
 
+import android.content.Intent
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
+import com.todoroo.astrid.activity.MainActivity
+import com.todoroo.astrid.activity.TaskListFragment
+import com.todoroo.astrid.api.CaldavFilter
+import com.todoroo.astrid.helper.UUIDHelper
+import com.todoroo.astrid.service.TaskDeleter
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.withContext
 import org.tasks.data.CaldavAccount
 import org.tasks.data.CaldavCalendar
+import org.tasks.data.CaldavDao
 import org.tasks.data.Principal
 import org.tasks.data.PrincipalDao
 import javax.inject.Inject
@@ -14,22 +22,80 @@ import javax.inject.Inject
 @HiltViewModel
 class CaldavCalendarViewModel @Inject constructor(
     private val provider: CaldavClientProvider,
-    private val principalDao: PrincipalDao
+    private val caldavDao: CaldavDao,
+    private val principalDao: PrincipalDao,
+    private val taskDeleter: TaskDeleter,
 ) : ViewModel() {
     val error = MutableLiveData<Throwable?>()
     val inFlight = MutableLiveData(false)
+    val finish = MutableLiveData<Intent>()
 
-    suspend fun remove(account: CaldavAccount, list: CaldavCalendar, principal: Principal) =
+    suspend fun createCalendar(caldavAccount: CaldavAccount, name: String, color: Int, icon: Int) =
+        doRequest {
+            val url = withContext(Dispatchers.IO) {
+                provider.forAccount(caldavAccount).makeCollection(name, color)
+            }
+            val calendar = CaldavCalendar().apply {
+                uuid = UUIDHelper.newUUID()
+                account = caldavAccount.uuid
+                this.url = url
+                this.name = name
+                this.color = color
+                setIcon(icon)
+                caldavDao.insert(this)
+            }
+            finish.value = Intent().putExtra(MainActivity.OPEN_FILTER, CaldavFilter(calendar))
+        }
+
+    suspend fun updateCalendar(
+        account: CaldavAccount,
+        calendar: CaldavCalendar,
+        name: String,
+        color: Int,
+        icon: Int
+    ) =
+        doRequest {
+            withContext(Dispatchers.IO) {
+                provider.forAccount(account, calendar.url!!).updateCollection(name, color)
+            }
+            calendar.apply {
+                this.name = name
+                this.color = color
+                setIcon(icon)
+                caldavDao.update(this)
+            }
+            finish.value = Intent(TaskListFragment.ACTION_RELOAD)
+                .putExtra(MainActivity.OPEN_FILTER, CaldavFilter(calendar))
+        }
+
+    suspend fun deleteCalendar(account: CaldavAccount, calendar: CaldavCalendar) =
+        doRequest {
+            withContext(Dispatchers.IO) {
+                provider.forAccount(account, calendar.url!!).deleteCollection()
+            }
+            taskDeleter.delete(calendar)
+            finish.value = Intent(TaskListFragment.ACTION_DELETED)
+        }
+
+    suspend fun removeUser(account: CaldavAccount, list: CaldavCalendar, principal: Principal) =
+        doRequest {
+            withContext(Dispatchers.IO) {
+                provider.forAccount(account).removePrincipal(account, list, principal)
+            }
+            principalDao.delete(principal)
+        }
+
+    private suspend fun <T> doRequest(action: suspend () -> T): T? =
         withContext(NonCancellable) {
             if (inFlight.value == true) {
-                return@withContext
+                return@withContext null
             }
             inFlight.value = true
             try {
-                provider.forAccount(account).removePrincipal(account, list, principal)
+                return@withContext action()
-                principalDao.delete(principal)
             } catch (e: Exception) {
                 error.value = e
+                return@withContext null
             } finally {
                 inFlight.value = false
             }

app/src/main/java/org/tasks/caldav/CreateCalendarViewModel.kt

@@ -1,15 +0,0 @@
-package org.tasks.caldav
-
-import dagger.hilt.android.lifecycle.HiltViewModel
-import org.tasks.data.CaldavAccount
-import org.tasks.ui.CompletableViewModel
-import javax.inject.Inject
-
-@HiltViewModel
-class CreateCalendarViewModel @Inject constructor(
-        private val provider: CaldavClientProvider
-): CompletableViewModel<String?>() {
-    suspend fun createCalendar(account: CaldavAccount, name: String, color: Int) {
-        run { provider.forAccount(account).makeCollection(name, color) }
-    }
-}

app/src/main/java/org/tasks/caldav/DeleteCalendarViewModel.kt

@@ -1,18 +0,0 @@
-package org.tasks.caldav
-
-import dagger.hilt.android.lifecycle.HiltViewModel
-import org.tasks.data.CaldavAccount
-import org.tasks.data.CaldavCalendar
-import org.tasks.ui.ActionViewModel
-import javax.inject.Inject
-
-@HiltViewModel
-class DeleteCalendarViewModel @Inject constructor(
-        private val provider: CaldavClientProvider
-) : ActionViewModel() {
-    suspend fun deleteCalendar(account: CaldavAccount, calendar: CaldavCalendar) {
-        run {
-            calendar.url?.let { provider.forAccount(account, it).deleteCollection() }
-        }
-    }
-}

app/src/main/java/org/tasks/caldav/UpdateCalendarViewModel.kt

@@ -1,18 +0,0 @@
-package org.tasks.caldav
-
-import dagger.hilt.android.lifecycle.HiltViewModel
-import org.tasks.data.CaldavAccount
-import org.tasks.data.CaldavCalendar
-import org.tasks.ui.CompletableViewModel
-import javax.inject.Inject
-
-@HiltViewModel
-class UpdateCalendarViewModel @Inject constructor(
-        private val provider: CaldavClientProvider
-) : CompletableViewModel<String?>() {
-    suspend fun updateCalendar(account: CaldavAccount, calendar: CaldavCalendar, name: String, color: Int) {
-        run {
-            calendar.url?.let { provider.forAccount(account, it).updateCollection(name, color) }
-        }
-    }
-}