keyword filtering on articles' titles

app/src/main/java/me/ash/reader/domain/model/feed/FeedWithKeywordFilter.kt

@@ -0,0 +1,15 @@
+package me.ash.reader.domain.model.feed
+
+import androidx.room.Embedded
+import androidx.room.Relation
+import me.ash.reader.domain.model.group.Group
+
+/**
+ * A [feed] with filtered keywords.
+ */
+data class FeedWithKeywordFilter(
+    @Embedded
+    var feed: Feed,
+    @Relation(parentColumn = "feedId", entityColumn = "id")
+    var keywordFilters: List<KeywordFilter>,
+)

app/src/main/java/me/ash/reader/domain/model/feed/KeywordFilter.kt

@@ -0,0 +1,25 @@
+package me.ash.reader.domain.model.feed
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+
+/**
+ * TODO: Add class description
+ */
+@Entity(
+    tableName = "keyword_filter",
+    primaryKeys = ["feedId", "keyword"],
+    foreignKeys = [
+        ForeignKey(
+            entity = Feed::class,
+            parentColumns = ["id"],
+            childColumns = ["feedId"],
+            onDelete = ForeignKey.CASCADE,
+            onUpdate = ForeignKey.CASCADE,
+        )
+    ]
+)
+data class KeywordFilter(
+    val feedId: String,
+    val keyword: String,
+)

app/src/main/java/me/ash/reader/domain/model/group/GroupWithFeedWithKeywordFilters.kt

@@ -0,0 +1,16 @@
+package me.ash.reader.domain.model.group
+
+import androidx.room.Embedded
+import androidx.room.Relation
+import me.ash.reader.domain.model.feed.Feed
+import me.ash.reader.domain.model.feed.FeedWithKeywordFilter
+
+/**
+ * A [group] contains many [feeds], each of which has [keyword_filters].
+ */
+data class GroupWithFeedWithKeywordFilters(
+    @Embedded
+    val group: Group,
+    @Relation(parentColumn = "id", entityColumn = "groupId")
+    val feedsWithKeywordFilters: MutableList<FeedWithKeywordFilter>,
+)

app/src/main/java/me/ash/reader/domain/repository/ArticleDao.kt

@@ -407,6 +407,16 @@ interface ArticleDao {
     )
     suspend fun deleteByFeedId(accountId: Int, feedId: String, includeStarred: Boolean = false)
 
+    @Query(
+        """
+        DELETE FROM article
+        WHERE accountId = :accountId
+        AND feedId = :feedId
+        AND title LIKE '%' || :keyword || '%'
+        """
+    )
+    suspend fun deleteByKeyword(accountId: Int, feedId: String, keyword: String)
+
     @Query(
         """
         DELETE FROM article
@@ -917,4 +927,12 @@ interface ArticleDao {
 
         return articles.filterNot { existingArticles.containsKey(it.link) }.also { insertList(it) }
     }
+
+    @Transaction
+    suspend fun deleteList(articles: List<Article>) {
+        articles.forEach {
+            println("delete : " + it.title)
+            delete(it)
+        }
+    }
 }

app/src/main/java/me/ash/reader/domain/repository/KeywordFilterDao.kt

@@ -0,0 +1,46 @@
+package me.ash.reader.domain.repository
+
+import androidx.room.Dao
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import kotlinx.coroutines.flow.Flow
+import me.ash.reader.domain.model.article.Article
+import me.ash.reader.domain.model.feed.FeedWithKeywordFilter
+import me.ash.reader.domain.model.feed.KeywordFilter
+
+@Dao
+interface KeywordFilterDao {
+
+    @Query(
+        """
+           SELECT * FROM `keyword_filter`
+           """
+    )
+    fun queryAll(): Flow<MutableList<KeywordFilter>>
+
+    @Query(
+        """
+           SELECT * FROM `keyword_filter`
+           """
+    )
+    suspend fun queryAllBlocking(): List<KeywordFilter>
+
+    @Query(
+        """
+           SELECT * FROM `keyword_filter`
+           WHERE feedId = :feedId
+           """
+    )
+    suspend fun queryAllWithFeedId(feedId: String): List<KeywordFilter>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insert(vararg filter: KeywordFilter)
+
+    @Delete
+    suspend fun delete(vararg filter: KeywordFilter)
+
+    @Insert
+    suspend fun insertList(filters: List<KeywordFilter>)
+}

app/src/main/java/me/ash/reader/domain/service/AbstractRssRepository.kt

@@ -12,6 +12,7 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flowOn
+import me.ash.reader.domain.model.feed.KeywordFilter
 import me.ash.reader.domain.model.account.Account
 import me.ash.reader.domain.model.article.ArchivedArticle
 import me.ash.reader.domain.model.article.Article
@@ -22,6 +23,7 @@ import me.ash.reader.domain.model.group.GroupWithFeed
 import me.ash.reader.domain.repository.ArticleDao
 import me.ash.reader.domain.repository.FeedDao
 import me.ash.reader.domain.repository.GroupDao
+import me.ash.reader.domain.repository.KeywordFilterDao
 import me.ash.reader.infrastructure.android.NotificationHelper
 import me.ash.reader.infrastructure.preference.KeepArchivedPreference
 import me.ash.reader.infrastructure.preference.SyncIntervalPreference
@@ -32,6 +34,7 @@ import me.ash.reader.ui.ext.spacerDollar
 abstract class AbstractRssRepository(
     private val articleDao: ArticleDao,
     private val groupDao: GroupDao,
+    private val keywordFilterDao: KeywordFilterDao,
     private val feedDao: FeedDao,
     private val workManager: WorkManager,
     private val rssHelper: RssHelper,
@@ -58,6 +61,7 @@ abstract class AbstractRssRepository(
         isNotification: Boolean,
         isFullContent: Boolean,
         isBrowser: Boolean,
+        filteredKeywords: List<String>
     ) {
         val accountId = accountService.getCurrentAccountId()
         val feed =
@@ -72,10 +76,14 @@ abstract class AbstractRssRepository(
                 isNotification = isNotification,
                 isFullContent = isFullContent,
             )
-        val articles =
-            searchedFeed.entries.map { rssHelper.buildArticleFromSyndEntry(feed, accountId, it) }
+        val articles = searchedFeed.entries.filter { article ->
+            filteredKeywords.none { keyword ->
+                article.title.lowercase().contains(keyword.lowercase())
+            }
+        }.map { rssHelper.buildArticleFromSyndEntry(feed, accountId, it) }
         feedDao.insert(feed)
         articleDao.insertList(articles.map { it.copy(feedId = feed.id) })
+        keywordFilterDao.insertList(filteredKeywords.map { KeywordFilter(feed.id, it) })
     }
 
     open suspend fun addGroup(destFeed: Feed?, newGroupName: String): String {
@@ -86,6 +94,10 @@ abstract class AbstractRssRepository(
         }
     }
 
+    open suspend fun addFilteredKeyword(feed: Feed, newFilteredKeyword: String) {
+        keywordFilterDao.insert(KeywordFilter(feedId = feed.id, keyword = newFilteredKeyword))
+    }
+
     abstract suspend fun sync(
         accountId: Int,
         feedId: String?,
@@ -209,6 +221,9 @@ abstract class AbstractRssRepository(
     fun pullGroups(): Flow<MutableList<Group>> =
         groupDao.queryAllGroup(accountService.getCurrentAccountId()).flowOn(dispatcherIO)
 
+    fun pullFilteredKeywords(): Flow<MutableList<KeywordFilter>> =
+        keywordFilterDao.queryAll().flowOn(dispatcherIO)
+
     fun pullFeeds(): Flow<MutableList<GroupWithFeed>> =
         groupDao
             .queryAllGroupWithFeedAsFlow(accountService.getCurrentAccountId())
@@ -341,6 +356,10 @@ abstract class AbstractRssRepository(
         groupDao.delete(group)
     }
 
+    open suspend fun deleteFilteredKeyword(keyword: KeywordFilter) {
+        keywordFilterDao.delete(keyword)
+    }
+
     open suspend fun deleteFeed(feed: Feed, onlyDeleteNoStarred: Boolean? = false) {
         if (
             onlyDeleteNoStarred == true &&
@@ -359,9 +378,17 @@ abstract class AbstractRssRepository(
     suspend fun deleteArticles(
         group: Group? = null,
         feed: Feed? = null,
+        keywordFilter: String? = null,
         includeStarred: Boolean = false,
     ) {
         when {
+            feed != null && keywordFilter != null ->
+                articleDao.deleteByKeyword(
+                    accountService.getCurrentAccountId(),
+                    feed.id,
+                    keywordFilter,
+                )
+
             group != null ->
                 articleDao.deleteByGroupId(
                     accountService.getCurrentAccountId(),

app/src/main/java/me/ash/reader/domain/service/FeverRssService.kt

@@ -24,6 +24,7 @@ import me.ash.reader.domain.model.group.Group
 import me.ash.reader.domain.repository.ArticleDao
 import me.ash.reader.domain.repository.FeedDao
 import me.ash.reader.domain.repository.GroupDao
+import me.ash.reader.domain.repository.KeywordFilterDao
 import me.ash.reader.infrastructure.android.NotificationHelper
 import me.ash.reader.infrastructure.di.DefaultDispatcher
 import me.ash.reader.infrastructure.di.IODispatcher
@@ -47,6 +48,7 @@ constructor(
     private val rssHelper: RssHelper,
     private val notificationHelper: NotificationHelper,
     private val groupDao: GroupDao,
+    private val keywordFilterDao: KeywordFilterDao,
     @IODispatcher private val ioDispatcher: CoroutineDispatcher,
     @MainDispatcher private val mainDispatcher: CoroutineDispatcher,
     @DefaultDispatcher private val defaultDispatcher: CoroutineDispatcher,
@@ -56,6 +58,7 @@ constructor(
     AbstractRssRepository(
         articleDao,
         groupDao,
+        keywordFilterDao,
         feedDao,
         workManager,
         rssHelper,
@@ -98,6 +101,7 @@ constructor(
         isNotification: Boolean,
         isFullContent: Boolean,
         isBrowser: Boolean,
+        filteredKeywords: List<String>
     ) {
         throw FeverAPIException("Unsupported")
     }
@@ -227,6 +231,7 @@ constructor(
                     break
                 }
 
+                val allFilteredKeywords = keywordFilterDao.queryAllBlocking()
                 val articlesFromBatch =
                     fetchedItems.map { item ->
                         Article(
@@ -248,6 +253,13 @@ constructor(
                             isStarred = (item.is_saved ?: 0) > 0,
                             updateAt = preDate,
                         )
+                    }.filter { article ->
+                        val filteredKeywordsForThisArticle = allFilteredKeywords.filter { keyword ->
+                            keyword.feedId == article.feedId
+                        }
+                        filteredKeywordsForThisArticle.none { keyword ->
+                            article.title.lowercase().contains(keyword.keyword.lowercase())
+                        }
                     }
 
                 allArticles.addAll(articlesFromBatch)

app/src/main/java/me/ash/reader/domain/service/GoogleReaderRssService.kt

@@ -33,10 +33,12 @@ import me.ash.reader.domain.model.account.AccountType.Companion.FreshRSS
 import me.ash.reader.domain.model.account.security.GoogleReaderSecurityKey
 import me.ash.reader.domain.model.article.Article
 import me.ash.reader.domain.model.feed.Feed
+import me.ash.reader.domain.model.feed.KeywordFilter
 import me.ash.reader.domain.model.group.Group
 import me.ash.reader.domain.repository.ArticleDao
 import me.ash.reader.domain.repository.FeedDao
 import me.ash.reader.domain.repository.GroupDao
+import me.ash.reader.domain.repository.KeywordFilterDao
 import me.ash.reader.infrastructure.android.NotificationHelper
 import me.ash.reader.infrastructure.di.DefaultDispatcher
 import me.ash.reader.infrastructure.di.IODispatcher
@@ -71,6 +73,7 @@ constructor(
     private val rssHelper: RssHelper,
     private val notificationHelper: NotificationHelper,
     private val groupDao: GroupDao,
+    private val keywordFilterDao: KeywordFilterDao,
     @IODispatcher private val ioDispatcher: CoroutineDispatcher,
     @MainDispatcher private val mainDispatcher: CoroutineDispatcher,
     @DefaultDispatcher private val defaultDispatcher: CoroutineDispatcher,
@@ -81,6 +84,7 @@ constructor(
     AbstractRssRepository(
         articleDao,
         groupDao,
+        keywordFilterDao,
         feedDao,
         workManager,
         rssHelper,
@@ -134,6 +138,7 @@ constructor(
         isNotification: Boolean,
         isFullContent: Boolean,
         isBrowser: Boolean,
+        filteredKeywords: List<String>
     ) {
         val accountId = accountService.getCurrentAccountId()
         val quickAdd = getGoogleReaderAPI().subscriptionQuickAdd(feedLink)
@@ -396,6 +401,7 @@ constructor(
                         unreadIds = remoteUnreadIds.await(),
                         starredIds = remoteStarredIds.await(),
                         scope = this,
+                        allFilteredKeywords = keywordFilterDao.queryAllBlocking()
                     )
                     .toMutableList()
 
@@ -563,6 +569,7 @@ constructor(
                     accountId = accountId,
                     unreadIds = remoteUnreadIds.await(),
                     starredIds = remoteStarredIds.await(),
+                    allFilteredKeywords = keywordFilterDao.queryAllBlocking()
                 )
 
             if (feed.isNotification) {
@@ -626,6 +633,7 @@ constructor(
         unreadIds: Set<String>,
         starredIds: Set<String>,
         scope: CoroutineScope,
+        allFilteredKeywords: List<KeywordFilter>,
     ): List<Deferred<List<Article>>> {
         if (itemIds.isEmpty()) return emptyList()
         val currentDate = Date()
@@ -671,7 +679,14 @@ constructor(
                                         ?: currentDate,
                             )
                         },
-                    )
+                    ).filter { article ->
+                        val filteredKeywordsForThisArticle = allFilteredKeywords.filter { keyword ->
+                            keyword.feedId == article.feedId
+                        }
+                        filteredKeywordsForThisArticle.none { keyword ->
+                            article.title.lowercase().contains(keyword.keyword.lowercase())
+                        }
+                    }
                 }
             }
         }
@@ -683,6 +698,7 @@ constructor(
         accountId: Int,
         unreadIds: Set<String>,
         starredIds: Set<String>,
+        allFilteredKeywords: List<KeywordFilter>
     ): List<Article> = supervisorScope {
         fetchItemsContentsDeferred(
                 itemIds = itemIds,
@@ -691,6 +707,7 @@ constructor(
                 unreadIds = unreadIds,
                 starredIds = starredIds,
                 scope = this,
+                allFilteredKeywords = allFilteredKeywords,
             )
             .awaitAll()
             .flatten()