Add article status table

app/build.gradle.kts

@@ -58,6 +58,7 @@ dependencies {
     implementation("androidx.activity:activity-compose:1.8.2")
     implementation("androidx.compose.material3:material3")
     implementation("androidx.compose.ui:ui")
+    implementation("androidx.compose.material:material:1.5.4")
     implementation("androidx.compose.ui:ui-graphics")
     implementation("androidx.compose.ui:ui-tooling-preview")
     implementation("androidx.core:core-ktx:1.12.0")

app/src/main/java/com/jocmp/basilreader/ui/accounts/AccountViewModel.kt

@@ -13,8 +13,9 @@ import com.jocmp.basil.AccountManager
 import com.jocmp.basil.Article
 import com.jocmp.basil.Feed
 import com.jocmp.basil.FeedFormEntry
+import com.jocmp.basil.Filter
 import com.jocmp.basil.Folder
-import com.jocmp.basil.feedPagingSource
+import com.jocmp.basil.buildPager
 import com.jocmp.basilreader.selectAccount
 import com.jocmp.basilreader.selectedAccount
 import kotlinx.coroutines.flow.first
@@ -29,18 +30,22 @@ class AccountViewModel(
         policy = neverEqualPolicy()
     )
 
+    private val pager: MutableState<Pager<Int, Article>?> = mutableStateOf(null)
+
     init {
         viewModelScope.launch {
             val accountID = settings.data.first().selectedAccount()
 
             if (accountID != null) {
-                updateState(accountID)
+                selectAccount(accountID)
             } else {
                 val firstID = accountManager.accountIDs().firstOrNull()
                 firstID?.let {
-                    selectAccount(firstID)
+                    selectSettingsAccount(firstID)
                 }
             }
+
+            pager.value = account?.buildPager()
         }
     }
 
@@ -54,8 +59,6 @@ class AccountViewModel(
 
     private val articleState = mutableStateOf<Article?>(null)
 
-    private val pager = mutableStateOf<Pager<Int, Article>?>(null)
-
     val feeds: List<Feed>
         get() = account?.feeds?.toList() ?: emptyList()
 
@@ -65,29 +68,42 @@ class AccountViewModel(
     fun articles(): Pager<Int, Article>? = pager.value
 
     fun selectFeed(feedID: String, onComplete: () -> Unit) {
-        this.feedID.value = feedID
+        val feed = account?.findFeed(feedID)
+
+        this.feedID.value = feed?.id
+
+        if (feed != null) {
+            pager.value = account?.buildPager(
+                filter = Filter.Feeds(feed = feed, status = Filter.Status.ALL),
+            )
+        }
 
-        pager.value = account?.feedPagingSource(this.feedID.value)
         clearArticle()
 
         onComplete()
     }
 
-    suspend fun selectArticle(articleID: String) {
-        articleState.value = account?.findArticle(articleID.toLong(), feedID.value?.toLongOrNull())
+    suspend fun refreshFeed() {
+        val id = feedID.value ?: return
+
+        account?.refreshFeed(id)
+    }
+
+    fun selectArticle(articleID: String) {
+        articleState.value = account?.findArticle(articleID.toLong())
     }
 
     fun clearArticle() {
         articleState.value = null
     }
 
-    private fun selectAccount(accountID: String) {
+    private fun selectSettingsAccount(accountID: String) {
         viewModelScope.launch {
             settings.selectAccount(accountID)
         }
     }
 
-    private fun updateState(accountID: String) {
+    private fun selectAccount(accountID: String) {
         accountState.value = accountManager.findByID(accountID)
     }
 

app/src/main/java/com/jocmp/basilreader/ui/articles/ArticleList.kt

@@ -1,45 +1,75 @@
 package com.jocmp.basilreader.ui.articles
 
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.material.ExperimentalMaterialApi
+import androidx.compose.material.pullrefresh.PullRefreshIndicator
+import androidx.compose.material.pullrefresh.pullRefresh
+import androidx.compose.material.pullrefresh.rememberPullRefreshState
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.paging.Pager
 import androidx.paging.compose.collectAsLazyPagingItems
 import com.jocmp.basil.Article
 import kotlinx.coroutines.launch
+import java.time.format.DateTimeFormatter
 
+@OptIn(ExperimentalMaterialApi::class)
 @Composable
 fun ArticleList(
     pager: Pager<Int, Article>,
+    onRefresh: suspend () -> Unit,
     onSelect: suspend (articleID: String) -> Unit,
 ) {
     val composableScope = rememberCoroutineScope()
     val lazyPagingItems = pager.flow.collectAsLazyPagingItems()
 
-    LazyColumn(Modifier.fillMaxWidth()) {
-        items(count = lazyPagingItems.itemCount) { index ->
-            val item = lazyPagingItems[index]
-            Column(
-                modifier = Modifier
-                    .padding(8.dp)
-                    .clickable {
-                        item?.let {
-                            composableScope.launch {
-                                onSelect(it.id)
+    val refreshScope = rememberCoroutineScope()
+    val (refreshing, setRefreshing) = remember { mutableStateOf(false) }
+
+    fun refresh() = refreshScope.launch {
+        setRefreshing(true)
+        onRefresh()
+        setRefreshing(false)
+    }
+
+    val state = rememberPullRefreshState(refreshing, ::refresh)
+
+    Box(Modifier.pullRefresh(state)) {
+
+        LazyColumn(Modifier.fillMaxWidth()) {
+            items(count = lazyPagingItems.itemCount) { index ->
+                val item = lazyPagingItems[index]
+                Column(
+                    modifier = Modifier
+                        .padding(8.dp)
+                        .clickable {
+                            item?.let {
+                                composableScope.launch {
+                                    onSelect(it.id)
+                                }
                             }
                         }
+                ) {
+                    item?.let { article ->
+                        Text(article.title, fontSize = 20.sp)
+                        Text(article.arrivedAt.format(DateTimeFormatter.BASIC_ISO_DATE))
                     }
-            ) {
-                Text(item?.title ?: "No title", fontSize = 20.sp)
+                }
             }
         }
+
+        PullRefreshIndicator(refreshing, state, Modifier.align(Alignment.TopCenter))
     }
 }

app/src/main/java/com/jocmp/basilreader/ui/articles/ArticleScreen.kt

@@ -51,6 +51,9 @@ fun ArticleScreen(
             viewModel.articles()?.let { pager ->
                 ArticleList(
                     pager = pager,
+                    onRefresh = {
+                        viewModel.refreshFeed()
+                    },
                     onSelect = {
                         viewModel.selectArticle(it)
                         navigateToDetail()

basil/src/main/java/com/jocmp/basil/Account.kt

@@ -2,13 +2,15 @@ package com.jocmp.basil
 
 import com.jocmp.basil.accounts.AccountDelegate
 import com.jocmp.basil.accounts.LocalAccountDelegate
-import com.jocmp.basil.articles.articleMapper
-import com.jocmp.basil.db.Articles
+import com.jocmp.basil.accounts.ParsedItem
+import com.jocmp.basil.accounts.asOPML
 import com.jocmp.basil.db.Database
-import com.jocmp.basil.feeds.FeedRecords
 import com.jocmp.basil.opml.Outline
 import com.jocmp.basil.opml.asFeed
 import com.jocmp.basil.opml.asFolder
+import com.jocmp.basil.persistence.FeedRecords
+import com.jocmp.basil.persistence.articleMapper
+import com.jocmp.basil.shared.nowUTC
 import com.jocmp.feedfinder.FeedFinder
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.coroutineScope
@@ -52,6 +54,10 @@ data class Account(
             addAll(folders.flatMap { it.feeds })
         }
 
+    fun findFeed(feedID: String): Feed? {
+        return flattenedFeeds.find { it.id == feedID }
+    }
+
     suspend fun addFolder(title: String): Folder {
         val folder = Folder(title = title)
 
@@ -86,19 +92,8 @@ data class Account(
         coroutineScope {
             launch {
                 val items = delegate.fetchAll(feed)
-                val feedID = feed.id.toLong()
-
-                items.forEach { item ->
-                    database.articlesQueries.create(
-                        feed_id = feedID,
-                        external_id = item.externalID,
-                        title = item.title,
-                        content_html = item.contentHTML,
-                        url = item.url,
-                        summary = item.summary,
-                        image_url = item.imageURL
-                    )
-                }
+
+                updateArticles(feed, items)
             }
         }
 
@@ -124,16 +119,41 @@ data class Account(
         return feed
     }
 
-    suspend fun findArticle(articleID: Long?, feedID: Long?): Article? {
+    suspend fun refreshFeed(feedID: String) {
+        val feed = flattenedFeeds.find { it.id == feedID } ?: return
+
+        val items = delegate.fetchAll(feed)
+
+        updateArticles(feed, items)
+    }
+
+    fun findArticle(articleID: Long?): Article? {
         articleID ?: return null
 
         return database.articlesQueries.findBy(
             articleID = articleID,
-            feedID = feedID,
             mapper = ::articleMapper
         ).executeAsOneOrNull()
     }
 
+    private fun updateArticles(feed: Feed, items: List<ParsedItem>) {
+        items.forEach { item ->
+            val publishedAt = item.publishedAt?.toEpochSecond()
+
+            database.articlesQueries.create(
+                feed_id = feed.primaryKey,
+                external_id = item.externalID,
+                title = item.title,
+                content_html = item.contentHTML,
+                url = item.url,
+                summary = item.summary,
+                image_url = item.imageURL,
+                published_at = publishedAt,
+                arrived_at = publishedAt ?: nowUTC()
+            )
+        }
+    }
+
     private fun entrySiteURL(url: URL?): String {
         return url?.toString() ?: ""
     }

basil/src/main/java/com/jocmp/basil/AccountPager.kt

@@ -0,0 +1,19 @@
+package com.jocmp.basil
+
+import androidx.paging.Pager
+import androidx.paging.PagingConfig
+import com.jocmp.basil.persistence.ArticlePagerFactory
+
+fun Account.buildPager(
+    filter: Filter = Filter.Articles(status = Filter.Status.ALL)
+): Pager<Int, Article> {
+    val pagerFactory = ArticlePagerFactory(
+        database = database,
+        filter = filter
+    )
+
+    return Pager(
+        config = PagingConfig(pageSize = 10),
+        pagingSourceFactory = { pagerFactory.find() }
+    )
+}

basil/src/main/java/com/jocmp/basil/Article.kt

@@ -1,6 +1,7 @@
 package com.jocmp.basil
 
 import java.net.URL
+import java.time.ZonedDateTime
 
 data class Article(
     val id: String,
@@ -10,5 +11,6 @@ data class Article(
     val contentHTML: String,
     val url: URL?,
     val summary: String,
-    val imageURL: URL?
+    val imageURL: URL?,
+    val arrivedAt: ZonedDateTime
 )

basil/src/main/java/com/jocmp/basil/Feed.kt

@@ -9,6 +9,9 @@ data class Feed(
     val feedURL: String,
     val siteURL: String = ""
 ) {
+    internal val primaryKey: Long
+        get() = id.toLong()
+
     override fun equals(other: Any?): Boolean {
         if (other is Feed) {
             return id == other.id
@@ -20,9 +23,3 @@ data class Feed(
         return id.hashCode()
     }
 }
-
-fun Feed.asOPML(indentLevel: Int): String {
-    val opml =
-        "<outline text=\"${name}\" title=\"${name}\" description=\"\" type=\"rss\" version=\"RSS\" htmlUrl=\"${siteURL}\" xmlUrl=\"${feedURL}\" basil_id=\"${id}\"/>\n"
-    return opml.prepending(tabCount = indentLevel)
-}

basil/src/main/java/com/jocmp/basil/Filter.kt

@@ -0,0 +1,15 @@
+package com.jocmp.basil
+
+sealed class Filter(val status: Status) {
+    enum class Status(value: String) {
+        ALL("all"),
+        READ("read"),
+        STARRED("starred")
+    }
+
+    class Articles(status: Status) : Filter(status)
+
+    class Feeds(val feed: Feed, status: Status) : Filter(status)
+
+    class Folders(val folder: Folder, status: Status) : Filter(status)
+}