Revert "Restore @Transaction annotations"

This reverts commit b35090cd43.

data/src/commonMain/kotlin/org/tasks/data/dao/CaldavDao.kt

@@ -4,13 +4,13 @@ import androidx.room.Dao
 import androidx.room.Delete
 import androidx.room.Insert
 import androidx.room.Query
-import androidx.room.Transaction
 import androidx.room.Update
 import kotlinx.coroutines.flow.Flow
 import org.tasks.data.CaldavFilters
 import org.tasks.data.CaldavTaskContainer
 import org.tasks.data.NO_ORDER
 import org.tasks.data.TaskContainer
+import org.tasks.data.db.Database
 import org.tasks.data.db.DbUtils.dbchunk
 import org.tasks.data.db.SuspendDbUtils.chunkedMap
 import org.tasks.data.entity.CaldavAccount
@@ -22,12 +22,13 @@ import org.tasks.data.entity.CaldavAccount.Companion.TYPE_TASKS
 import org.tasks.data.entity.CaldavCalendar
 import org.tasks.data.entity.CaldavTask
 import org.tasks.data.entity.Task
+import org.tasks.data.withTransaction
 import org.tasks.time.DateTimeUtils2.currentTimeMillis
 
 const val APPLE_EPOCH = 978307200000L // 1/1/2001 GMT
 
 @Dao
-abstract class CaldavDao {
+abstract class CaldavDao(private val database: Database) {
     @Query("SELECT COUNT(*) FROM caldav_lists WHERE cdl_account = :account")
     abstract suspend fun listCount(account: String): Int
 
@@ -98,10 +99,10 @@ ORDER BY CASE cda_account_type
     @Update
     abstract suspend fun update(caldavCalendar: CaldavCalendar)
 
-    @Transaction
+    suspend fun insert(task: Task, caldavTask: CaldavTask, addToTop: Boolean): Long =
-    open suspend fun insert(task: Task, caldavTask: CaldavTask, addToTop: Boolean): Long {
+        database.withTransaction {
             if (task.order != null) {
-            return insert(caldavTask)
+                return@withTransaction insert(caldavTask)
             }
             if (addToTop) {
                 task.order = findFirstTask(caldavTask.calendar!!, task.parent)
@@ -114,7 +115,7 @@ ORDER BY CASE cda_account_type
             }
             val id = insert(caldavTask)
             update(task)
-        return id
+            id
         }
 
     @Query("""
@@ -311,13 +312,13 @@ GROUP BY caldav_lists.cdl_uuid
             + "WHERE _id IN (SELECT _id FROM tasks INNER JOIN caldav_tasks ON _id = cd_task WHERE cd_deleted = 0 AND cd_calendar = :calendar)")
     abstract suspend fun updateParents(calendar: String)
 
-    @Transaction
+    suspend fun move(
-    open suspend fun move(
         task: TaskContainer,
         previousParent: Long,
         newParent: Long,
         newPosition: Long?,
     ) {
+        database.withTransaction {
             val previousPosition = task.caldavSortOrder
             if (newPosition != null) {
                 if (newParent == previousParent && newPosition < previousPosition) {
@@ -331,9 +332,10 @@ GROUP BY caldav_lists.cdl_uuid
             task.task.order = newPosition
             setTaskOrder(task.id, newPosition)
         }
+    }
 
-    @Transaction
+    suspend fun shiftDown(calendar: String, parent: Long, from: Long, to: Long? = null) {
-    open suspend fun shiftDown(calendar: String, parent: Long, from: Long, to: Long? = null) {
+        database.withTransaction {
             val updated = ArrayList<Task>()
             val tasks = getTasksToShift(calendar, parent, from, to)
             for (i in tasks.indices) {
@@ -353,6 +355,7 @@ GROUP BY caldav_lists.cdl_uuid
                 .dbchunk()
                 .forEach { touchInternal(it) }
         }
+    }
 
     @Query("UPDATE tasks SET modified = :modificationTime WHERE _id in (:ids)")
     internal abstract suspend fun touchInternal(ids: List<Long>, modificationTime: Long = currentTimeMillis())

data/src/commonMain/kotlin/org/tasks/data/dao/DeletionDao.kt

@@ -3,15 +3,16 @@ package org.tasks.data.dao
 import androidx.room.Dao
 import androidx.room.Delete
 import androidx.room.Query
-import androidx.room.Transaction
 import org.tasks.data.dao.CaldavDao.Companion.LOCAL
+import org.tasks.data.db.Database
 import org.tasks.data.db.SuspendDbUtils.chunkedMap
 import org.tasks.data.db.SuspendDbUtils.eachChunk
 import org.tasks.data.entity.CaldavAccount
 import org.tasks.data.entity.CaldavCalendar
+import org.tasks.data.withTransaction
 
 @Dao
-abstract class DeletionDao {
+abstract class DeletionDao(private val database: Database) {
     @Query("DELETE FROM tasks WHERE _id IN(:ids)")
     internal abstract suspend fun deleteTasks(ids: List<Long>)
 
@@ -58,12 +59,12 @@ WHERE recurring = 1
     @Delete
     internal abstract suspend fun deleteCaldavCalendar(caldavCalendar: CaldavCalendar)
 
-    @Transaction
+    suspend fun delete(caldavCalendar: CaldavCalendar): List<Long> =
-    open suspend fun delete(caldavCalendar: CaldavCalendar): List<Long> {
+        database.withTransaction {
             val tasks = getActiveCaldavTasks(caldavCalendar.uuid!!)
             delete(tasks)
             deleteCaldavCalendar(caldavCalendar)
-        return tasks
+            tasks
         }
 
     @Query("SELECT * FROM caldav_lists WHERE cdl_account = :account")
@@ -75,13 +76,13 @@ WHERE recurring = 1
     @Query("DELETE FROM tasks WHERE _id IN (SELECT _id FROM tasks INNER JOIN caldav_tasks ON _id = cd_task INNER JOIN caldav_lists ON cdl_uuid = cd_calendar WHERE cdl_account = '$LOCAL' AND deleted > 0 AND cd_deleted = 0)")
     abstract suspend fun purgeDeleted()
 
-    @Transaction
+    suspend fun delete(caldavAccount: CaldavAccount): List<Long> =
-    open suspend fun delete(caldavAccount: CaldavAccount): List<Long> {
+        database.withTransaction {
             val deleted = ArrayList<Long>()
             for (calendar in getCalendars(caldavAccount.uuid!!)) {
                 deleted.addAll(delete(calendar))
             }
             deleteCaldavAccount(caldavAccount)
-        return deleted
+            deleted
         }
 }

data/src/commonMain/kotlin/org/tasks/data/dao/GoogleTaskDao.kt

@@ -4,22 +4,23 @@ import androidx.room.Dao
 import androidx.room.Delete
 import androidx.room.Insert
 import androidx.room.Query
-import androidx.room.Transaction
 import androidx.room.Update
+import org.tasks.data.db.Database
 import org.tasks.data.entity.CaldavAccount.Companion.TYPE_GOOGLE_TASKS
 import org.tasks.data.entity.CaldavTask
 import org.tasks.data.entity.Task
+import org.tasks.data.withTransaction
 
 @Dao
-abstract class GoogleTaskDao {
+abstract class GoogleTaskDao(private val database: Database) {
     @Insert
     abstract suspend fun insert(task: CaldavTask): Long
 
     @Insert
     abstract suspend fun insert(tasks: Iterable<CaldavTask>)
 
-    @Transaction
+    suspend fun insertAndShift(task: Task, caldavTask: CaldavTask, top: Boolean) {
-    open suspend fun insertAndShift(task: Task, caldavTask: CaldavTask, top: Boolean) {
+        database.withTransaction {
             if (top) {
                 task.order = 0
                 shiftDown(caldavTask.calendar!!, task.parent, 0)
@@ -29,6 +30,7 @@ abstract class GoogleTaskDao {
             insert(caldavTask)
             update(task)
         }
+    }
 
     @Query("UPDATE tasks SET `order` = `order` + 1 WHERE parent = :parent AND `order` >= :position AND _id IN (SELECT cd_task FROM caldav_tasks WHERE cd_calendar = :listId)")
     internal abstract suspend fun shiftDown(listId: String, parent: Long, position: Long)
@@ -42,8 +44,8 @@ abstract class GoogleTaskDao {
     @Query("UPDATE tasks SET `order` = `order` - 1 WHERE parent = :parent AND `order` >= :position AND _id IN (SELECT cd_task FROM caldav_tasks WHERE cd_calendar = :listId)")
     internal abstract suspend fun shiftUp(listId: String, parent: Long, position: Long)
 
-    @Transaction
+    suspend fun move(task: Task, list: String, newParent: Long, newPosition: Long) {
-    open suspend fun move(task: Task, list: String, newParent: Long, newPosition: Long) {
+        database.withTransaction {
             val previousParent = task.parent
             val previousPosition = task.order!!
             if (newParent == previousParent) {
@@ -61,6 +63,7 @@ abstract class GoogleTaskDao {
             update(task)
             setMoved(task.id, list)
         }
+    }
 
     @Query("UPDATE caldav_tasks SET gt_moved = 1 WHERE cd_task = :task and cd_calendar = :list")
     internal abstract suspend fun setMoved(task: Long, list: String)
@@ -165,8 +168,8 @@ WHERE cd_remote_id = :id
     """)
     abstract suspend fun updatePosition(id: String, parent: String?, position: String)
 
-    @Transaction
+    suspend fun reposition(caldavDao: CaldavDao, listId: String) {
-    open suspend fun reposition(caldavDao: CaldavDao, listId: String) {
+        database.withTransaction {
             caldavDao.updateParents(listId)
             val orderedTasks = getByRemoteOrder(listId)
             var subtasks = 0L
@@ -188,6 +191,7 @@ WHERE cd_remote_id = :id
                 }
             }
         }
+    }
 
     suspend fun validateSorting(listId: String) {
         val orderedTasks = getByLocalOrder(listId)

data/src/commonMain/kotlin/org/tasks/data/dao/PrincipalDao.kt

@@ -4,39 +4,43 @@ import androidx.room.Dao
 import androidx.room.Delete
 import androidx.room.Insert
 import androidx.room.Query
-import androidx.room.Transaction
 import androidx.room.Update
 import kotlinx.coroutines.flow.Flow
 import org.tasks.data.PrincipalWithAccess
+import org.tasks.data.db.Database
 import org.tasks.data.entity.CaldavAccount
 import org.tasks.data.entity.CaldavCalendar
 import org.tasks.data.entity.Principal
 import org.tasks.data.entity.PrincipalAccess
+import org.tasks.data.withTransaction
 
 @Dao
-interface PrincipalDao {
+abstract class PrincipalDao(private val database: Database) {
     @Insert
-    suspend fun insert(principal: Principal): Long
+    abstract suspend fun insert(principal: Principal): Long
 
     @Insert
-    suspend fun insert(access: PrincipalAccess): Long
+    abstract suspend fun insert(access: PrincipalAccess): Long
 
     @Update
-    suspend fun update(access: PrincipalAccess)
+    abstract suspend fun update(access: PrincipalAccess)
 
     @Query("""
 DELETE
 FROM principal_access
 WHERE list = :list
   AND id NOT IN (:access)""")
-    suspend fun deleteRemoved(list: Long, access: List<Long>)
+    abstract suspend fun deleteRemoved(list: Long, access: List<Long>)
 
     @Delete
-    suspend fun delete(access: PrincipalAccess)
+    abstract suspend fun delete(access: PrincipalAccess)
+
+    suspend fun getAll(): List<PrincipalWithAccess> = database.withTransaction {
+        getAllInternal()
+    }
 
-    @Transaction
     @Query("SELECT * FROM principal_access")
-    suspend fun getAll(): List<PrincipalWithAccess>
+    internal abstract suspend fun getAllInternal(): List<PrincipalWithAccess>
 
     suspend fun getOrCreatePrincipal(account: CaldavAccount, href: String, displayName: String? = null) =
         findPrincipal(account.id, href)
@@ -65,12 +69,12 @@ WHERE list = :list
             ).apply { id = insert(this) }
 
     @Query("SELECT * FROM principals WHERE account = :account AND href = :href")
-    suspend fun findPrincipal(account: Long, href: String): Principal?
+    abstract suspend fun findPrincipal(account: Long, href: String): Principal?
 
     @Query("SELECT * FROM principal_access WHERE list = :list and principal = :principal")
-    suspend fun findAccess(list: Long, principal: Long): PrincipalAccess?
+    abstract suspend fun findAccess(list: Long, principal: Long): PrincipalAccess?
 
-    @Transaction
     @Query("SELECT * FROM principal_access WHERE list = :id")
-    fun getPrincipals(id: Long): Flow<List<PrincipalWithAccess>>
+    abstract fun getPrincipals(id: Long): Flow<List<PrincipalWithAccess>>
+
 }

data/src/commonMain/kotlin/org/tasks/data/dao/TagDao.kt

@@ -4,13 +4,14 @@ import androidx.room.Dao
 import androidx.room.Delete
 import androidx.room.Insert
 import androidx.room.Query
-import androidx.room.Transaction
+import org.tasks.data.db.Database
 import org.tasks.data.entity.Tag
 import org.tasks.data.entity.TagData
 import org.tasks.data.entity.Task
+import org.tasks.data.withTransaction
 
 @Dao
-abstract class TagDao {
+abstract class TagDao(private val database: Database) {
     @Query("UPDATE tags SET name = :name WHERE tag_uid = :tagUid")
     abstract suspend fun rename(tagUid: String, name: String)
 
@@ -35,8 +36,8 @@ abstract class TagDao {
     @Delete
     abstract suspend fun delete(tags: List<Tag>)
 
-    @Transaction
     open suspend fun applyTags(task: Task, tagDataDao: TagDataDao, current: List<TagData>) {
+        database.withTransaction {
             val taskId = task.id
             val existing = HashSet(tagDataDao.getTagDataForTask(taskId))
             val selected = HashSet<TagData>(current)
@@ -45,6 +46,7 @@ abstract class TagDao {
             deleteTags(taskId, removed.map { td -> td.remoteId!! })
             insert(task, added)
         }
+    }
 
     suspend fun insert(task: Task, tags: Collection<TagData>) {
         if (!tags.isEmpty()) {

data/src/commonMain/kotlin/org/tasks/data/dao/TagDataDao.kt

@@ -4,19 +4,20 @@ import androidx.room.Dao
 import androidx.room.Delete
 import androidx.room.Insert
 import androidx.room.Query
-import androidx.room.Transaction
 import androidx.room.Update
 import kotlinx.coroutines.flow.Flow
 import org.tasks.data.NO_ORDER
 import org.tasks.data.TagFilters
+import org.tasks.data.db.Database
 import org.tasks.data.db.DbUtils
 import org.tasks.data.entity.Tag
 import org.tasks.data.entity.TagData
 import org.tasks.data.entity.Task
+import org.tasks.data.withTransaction
 import org.tasks.time.DateTimeUtils2.currentTimeMillis
 
 @Dao
-abstract class TagDataDao {
+abstract class TagDataDao(private val database: Database) {
     @Query("SELECT * FROM tagdata")
     abstract fun subscribeToTags(): Flow<List<TagData>>
 
@@ -79,12 +80,11 @@ abstract class TagDataDao {
             + " GROUP BY tasks._id")
     internal abstract suspend fun getAllTags(tasks: List<Long>): List<String?>
 
-    @Transaction
+    suspend fun applyTags(
-    open suspend fun applyTags(
         tasks: List<Task>,
         partiallySelected: List<TagData>,
         selected: List<TagData>
-    ): List<Long> {
+    ): List<Long> = database.withTransaction {
         val modified = HashSet<Long>()
         val keep = partiallySelected.plus(selected).map { it.remoteId!! }
         for (sublist in tasks.chunked(DbUtils.MAX_SQLITE_ARGS - keep.size)) {
@@ -108,14 +108,15 @@ abstract class TagDataDao {
                 )
             }
         }
-        return ArrayList(modified)
+        ArrayList(modified)
     }
 
-    @Transaction
+    suspend fun delete(tagData: TagData) {
-    open suspend fun delete(tagData: TagData) {
+        database.withTransaction {
             deleteTags(tagData.remoteId!!)
             deleteTagData(tagData)
         }
+    }
 
     @Delete
     abstract suspend fun delete(tagData: List<TagData>)