Add support for all cases of setting all items read for all account types

appcompose/src/main/java/com/readrops/app/compose/repositories/Repository.kt

@@ -111,33 +111,96 @@ abstract class BaseRepository(
         }
     }
 
-    open suspend fun setAllItemsRead(accountId: Int) {
+    open suspend fun setAllItemsRead() {
+        val accountId = account.id
+
+        when {
+            account.config.useSeparateState -> {
+                database.newItemStateChangeDao().upsertAllItemsReadStateChanges(accountId)
+                database.newItemStateDao().setAllItemsRead(accountId)
+            }
+            account.isLocal -> {
+                database.newItemDao().setAllItemsRead(account.id)
+            }
+            else -> {
+                database.newItemStateChangeDao().upsertAllItemsReadStateChanges(accountId)
                 database.newItemDao().setAllItemsRead(accountId)
             }
+        }
+    }
 
-    open suspend fun setAllStarredItemsRead(accountId: Int) {
+    open suspend fun setAllStarredItemsRead() {
+        val accountId = account.id
+
+        when {
+            account.config.useSeparateState -> {
+                database.newItemStateChangeDao().upsertStarredItemReadStateChanges(accountId)
+                database.newItemStateDao().setAllStarredItemsRead(accountId)
+            }
+            account.isLocal -> {
                 database.newItemDao().setAllStarredItemsRead(accountId)
             }
-
+            else -> {
-    open suspend fun setAllNewItemsRead(accountId: Int) {
+                database.newItemStateChangeDao().upsertStarredItemReadStateChanges(accountId)
-        database.newItemDao().setAllNewItemsRead(accountId)
+                database.newItemDao().setAllStarredItemsRead(accountId)
+            }
+        }
     }
 
-    open suspend fun setAllItemsReadByFeed(feedId: Int, accountId: Int) {
+    open suspend fun setAllNewItemsRead() {
+        val accountId = account.id
+
         when {
-            account.config.useSeparateState || !account.isLocal -> {
+            account.config.useSeparateState -> {
-                database.newItemStateChangeDao().upsertItemReadStateChangesByFeed(feedId, accountId)
+                database.newItemStateChangeDao().upsertNewItemReadStateChanges(accountId)
+                database.newItemStateDao().setAllNewItemsRead(accountId)
+            }
+            account.isLocal -> {
+                database.newItemDao().setAllNewItemsRead(accountId)
+            }
+            else -> {
+                database.newItemStateChangeDao().upsertNewItemReadStateChanges(accountId)
+                database.newItemDao().setAllNewItemsRead(accountId)
+            }
+        }
+    }
+
+    open suspend fun setAllItemsReadByFeed(feedId: Int) {
+        val accountId = account.id
+
+        when {
+            account.config.useSeparateState -> {
+                database.newItemStateChangeDao()
+                    .upsertItemReadStateChangesByFeed(feedId, accountId)
                 database.newItemStateDao().setAllItemsReadByFeed(feedId, accountId)
             }
             account.isLocal -> {
                 database.newItemDao().setAllItemsReadByFeed(feedId, accountId)
             }
+            else -> {
+                database.newItemStateChangeDao().upsertItemReadStateChangesByFeed(feedId, accountId)
+                database.newItemDao().setAllItemsReadByFeed(feedId, accountId)
+            }
         }
     }
 
-    open suspend fun setAllItemsReadByFolder(folderId: Int, accountId: Int) {
+    open suspend fun setAllItemsReadByFolder(folderId: Int) {
+        val accountId = account.id
+
+        when {
+            account.config.useSeparateState -> {
+                database.newItemStateChangeDao().upsertItemReadStateChangesByFolder(folderId, accountId)
+                database.newItemStateDao().setAllItemsReadByFolder(folderId, accountId)
+            }
+            account.isLocal -> {
                 database.newItemDao().setAllItemsReadByFolder(folderId, accountId)
             }
+            else -> {
+                database.newItemStateChangeDao().upsertItemReadStateChangesByFolder(folderId, accountId)
+                database.newItemDao().setAllItemsReadByFolder(folderId, accountId)
+            }
+        }
+    }
 
     suspend fun insertOPMLFoldersAndFeeds(
         foldersAndFeeds: Map<Folder?, List<Feed>>,

appcompose/src/main/java/com/readrops/app/compose/timelime/TimelineScreenModel.kt

@@ -274,24 +274,20 @@ class TimelineScreenModel(
 
     fun setAllItemsRead() {
         screenModelScope.launch(dispatcher) {
-            val accountId = currentAccount!!.id
-
             when (_timelineState.value.filters.subFilter) {
                 SubFilter.FEED ->
                     repository?.setAllItemsReadByFeed(
-                        feedId = _timelineState.value.filters.filterFeedId,
+                        feedId = _timelineState.value.filters.filterFeedId
-                        accountId = accountId
                     )
 
                 SubFilter.FOLDER -> repository?.setAllItemsReadByFolder(
-                    folderId = _timelineState.value.filters.filterFolderId,
+                    folderId = _timelineState.value.filters.filterFolderId
-                    accountId = accountId
                 )
 
                 else -> when (_timelineState.value.filters.mainFilter) {
-                    MainFilter.STARS -> repository?.setAllStarredItemsRead(accountId)
+                    MainFilter.STARS -> repository?.setAllStarredItemsRead()
-                    MainFilter.ALL -> repository?.setAllItemsRead(accountId)
+                    MainFilter.ALL -> repository?.setAllItemsRead()
-                    MainFilter.NEW -> repository?.setAllNewItemsRead(accountId)
+                    MainFilter.NEW -> repository?.setAllNewItemsRead()
                 }
             }
         }

db/src/main/java/com/readrops/db/dao/newdao/NewItemStateChangeDao.kt

@@ -97,18 +97,77 @@ interface NewItemStateChangeDao: NewBaseDao<ItemStateChange> {
     @Query("Update ItemStateChange set star_change = :starChange Where id = :id")
     suspend fun updateItemStarStateChange(starChange: Boolean, id: Int)
 
+    suspend fun upsertAllItemsReadStateChanges(accountId: Int) {
+        upsertAllItemsReadStateChangesByUpdate(accountId)
+        upsertAllItemsReadStateChangesByInsert(accountId)
+    }
+
+    @Query("""Update ItemStateChange Set read_change = 1 Where id In (Select Item.id From Item 
+        Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId)""")
+    suspend fun upsertAllItemsReadStateChangesByUpdate(accountId: Int)
+
+    @Query("""Insert Or Ignore Into ItemStateChange(id, read_change, star_change, account_id) 
+        Select Item.id, 1 as read_change, 0 as star_change, account_id
+        From Item Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId""")
+    suspend fun upsertAllItemsReadStateChangesByInsert(accountId: Int)
+
     suspend fun upsertItemReadStateChangesByFeed(feedId: Int, accountId: Int) {
-        upsertItemsReadStateChangesByFeedByUpdate(feedId, accountId)
+        upsertItemReadStateChangesByFeedByUpdate(feedId, accountId)
-        upsertItemsReadStateChangesByFeedByInsert(feedId, accountId)
+        upsertItemReadStateChangesByFeedByInsert(feedId, accountId)
     }
 
     @Query("""Update ItemStateChange Set read_change = 1 Where id In (Select Item.id From Item 
         Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId And feed_id = :feedId)""")
-    suspend fun upsertItemsReadStateChangesByFeedByUpdate(feedId: Int, accountId: Int)
+    suspend fun upsertItemReadStateChangesByFeedByUpdate(feedId: Int, accountId: Int)
 
     @Query("""Insert Or Ignore Into ItemStateChange(id, read_change, star_change, account_id) 
         Select Item.id, 1 as read_change, 0 as star_change, account_id
         From Item Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId And feed_id = :feedId""")
-    suspend fun upsertItemsReadStateChangesByFeedByInsert(feedId: Int, accountId: Int)
+    suspend fun upsertItemReadStateChangesByFeedByInsert(feedId: Int, accountId: Int)
 
+    suspend fun upsertItemReadStateChangesByFolder(folderId: Int, accountId: Int) {
+        upsertItemReadStateChangesByFolderByUpdate(folderId, accountId)
+        upsertItemReadStateChangesByFolderByInsert(folderId, accountId)
+    }
+
+    @Query("""Update ItemStateChange Set read_change = 1 Where id In (Select Item.id From Item 
+        Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId And folder_id = :folderId)""")
+    suspend fun upsertItemReadStateChangesByFolderByUpdate(folderId: Int, accountId: Int)
+
+    @Query("""Insert Or Ignore Into ItemStateChange(id, read_change, star_change, account_id) 
+        Select Item.id, 1 as read_change, 0 as star_change, account_id
+        From Item Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId And folder_id = :folderId""")
+    suspend fun upsertItemReadStateChangesByFolderByInsert(folderId: Int, accountId: Int)
+
+    suspend fun upsertStarredItemReadStateChanges(accountId: Int) {
+        upsertStarredItemReadStateChangesByUpdate(accountId)
+        upsertStarredItemReadStateChangesByInsert(accountId)
+    }
+
+    @Query("""Update ItemStateChange Set read_change = 1 Where id In (Select Item.id From Item 
+        Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId And starred = 1)""")
+    suspend fun upsertStarredItemReadStateChangesByUpdate(accountId: Int)
+
+    @Query("""Insert Or Ignore Into ItemStateChange(id, read_change, star_change, account_id) 
+        Select Item.id, 1 as read_change, 0 as star_change, account_id
+        From Item Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId And starred = 1""")
+    suspend fun upsertStarredItemReadStateChangesByInsert(accountId: Int)
+
+    suspend fun upsertNewItemReadStateChanges(accountId: Int) {
+        upsertNewItemReadStateChangesByUpdate(accountId)
+        upsertNewItemReadStateChangesByInsert(accountId)
+    }
+
+    @Query("""Update ItemStateChange Set read_change = 1 Where id In (Select Item.id From Item 
+        Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId
+        And DateTime(Round(Item.pub_date / 1000), 'unixepoch') 
+        Between DateTime(DateTime("now"), "-24 hour") And DateTime("now"))""")
+    suspend fun upsertNewItemReadStateChangesByUpdate(accountId: Int)
+
+    @Query("""Insert Or Ignore Into ItemStateChange(id, read_change, star_change, account_id) 
+        Select Item.id, 1 as read_change, 0 as star_change, account_id
+        From Item Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId 
+        And DateTime(Round(Item.pub_date / 1000), 'unixepoch') 
+        Between DateTime(DateTime("now"), "-24 hour") And DateTime("now")""")
+    suspend fun upsertNewItemReadStateChangesByInsert(accountId: Int)
 }

db/src/main/java/com/readrops/db/dao/newdao/NewItemStateDao.kt

@@ -16,7 +16,8 @@ interface NewItemStateDao : NewBaseDao<ItemState> {
     @Query("Update ItemState set starred = :star Where remote_id = :remoteId And account_id = :accountId")
     suspend fun updateItemStarState(star: Boolean, remoteId: String, accountId: Int)
 
-    @Query("Select case When Exists (Select remote_id, account_id From ItemState Where remote_id = :remoteId And account_id = :accountId) Then 1 else 0 End")
+    @Query("""Select case When Exists (Select remote_id, account_id From ItemState 
+        Where remote_id = :remoteId And account_id = :accountId) Then 1 else 0 End""")
     suspend fun itemStateExists(remoteId: String, accountId: Int): Boolean
 
     suspend fun upsertItemReadState(itemState: ItemState) {
@@ -35,8 +36,18 @@ interface NewItemStateDao : NewBaseDao<ItemState> {
         }
     }
 
-    @Query("Insert Or Replace Into ItemState(read, remote_id) Select 1 as read, Item.remoteId From Item Inner Join Feed On Feed.account_id = :accountId")
+    suspend fun setAllItemsRead(accountId: Int) {
-    suspend fun setAllItemsRead(accountId: Int)
+        setAllItemsReadByUpdate(accountId)
+        //setAllItemsReadByInsert(accountId) //TODO use this after putting ItemState.remoteId UNIQUE?
+    }
+
+    @Query("""Update ItemState set read = 1 Where remote_id In (Select Item.remoteId From Item 
+        Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId)""")
+    suspend fun setAllItemsReadByUpdate(accountId: Int)
+
+    @Query("""Insert Or Ignore Into ItemState(read, starred, remote_id) Select 1 as read, 0 as starred, 
+        Item.remoteId From Item Inner Join Feed Where Feed.account_id = :accountId""")
+    suspend fun setAllItemsReadByInsert(accountId: Int)
 
     suspend fun setAllItemsReadByFeed(feedId: Int, accountId: Int) {
         setAllItemsReadByFeedByUpdate(feedId, accountId)
@@ -50,4 +61,38 @@ interface NewItemStateDao : NewBaseDao<ItemState> {
     @Query("""Insert Or Ignore Into ItemState(read, starred, remote_id) Select 1 as read, 0 as starred, 
         Item.remoteId From Item Inner Join Feed Where Feed.account_id = :accountId And feed_id = :feedId""")
     suspend fun setAllItemsReadByFeedByInsert(feedId: Int, accountId: Int)
+
+    suspend fun setAllItemsReadByFolder(folderId: Int, accountId: Int) {
+        setAllItemsReadByFolderByUpdate(folderId, accountId)
+        //setAllItemsReadByFolderByInsert(folderId, accountId) //TODO use this after putting ItemState.remoteId UNIQUE?
+    }
+
+    @Query("""Update ItemState set read = 1 Where remote_id In (Select Item.remoteId From Item 
+        Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId and folder_id = :folderId)""")
+    suspend fun setAllItemsReadByFolderByUpdate(folderId: Int, accountId: Int)
+
+    @Query("""Insert Or Ignore Into ItemState(read, starred, remote_id) Select 1 as read, 0 as starred, 
+        Item.remoteId From Item Inner Join Feed Where Feed.account_id = :accountId And folder_id = :folderId""")
+    suspend fun setAllItemsReadByFolderByInsert(folderId: Int, accountId: Int)
+
+    @Query("""Update ItemState set read = 1 Where remote_id In (Select Item.remoteId From Item 
+        Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId And starred = 1)""")
+    suspend fun setAllStarredItemsRead(accountId: Int)
+
+    suspend fun setAllNewItemsRead(accountId: Int) {
+        setAllNewItemsReadByUpdate(accountId)
+        //setAllItemsReadByInsert(accountId) //TODO use this after putting ItemState.remoteId UNIQUE?
+    }
+
+    @Query("""Update ItemState set read = 1 Where remote_id In (Select Item.remoteId From Item 
+        Inner Join Feed On Feed.id = Item.feed_id Where account_id = :accountId 
+        And DateTime(Round(Item.pub_date / 1000), 'unixepoch') 
+        Between DateTime(DateTime("now"), "-24 hour") And DateTime("now"))""")
+    suspend fun setAllNewItemsReadByUpdate(accountId: Int)
+
+    @Query("""Insert Or Ignore Into ItemState(read, starred, remote_id) Select 1 as read, 0 as starred, 
+        Item.remoteId From Item Inner Join Feed Where Feed.account_id = :accountId 
+        And DateTime(Round(Item.pub_date / 1000), 'unixepoch') 
+        Between DateTime(DateTime("now"), "-24 hour") And DateTime("now")""")
+    suspend fun setAllNewItemsReadByInsert(accountId: Int)
 }