Get rid of EntriesRepo

Author: bubelov

app/src/main/kotlin/org/vestifeed/app/App.kt

@@ -7,13 +7,12 @@ import androidx.sqlite.driver.AndroidSQLiteDriver
 import org.vestifeed.api.Api
 import org.vestifeed.api.HotSwapApi
 import org.vestifeed.db.Database
-import org.vestifeed.entries.EntriesRepo
 import org.vestifeed.sync.Sync
 import java.io.File
 
 class App : Application() {
 
-    val sync by lazy { Sync(api, db, EntriesRepo(api, db)) }
+    val sync by lazy { Sync(api, db) }
 
     val api by lazy { HotSwapApi(db) }
 
@@ -25,7 +24,7 @@ class App : Application() {
     }
 
     fun databaseFile(): File {
-        return getDatabasePath("vesti-2026-03-17.org.vestifeed.db")
+        return getDatabasePath("vesti.db")
     }
 }
 

app/src/main/kotlin/org/vestifeed/entries/EntriesRepo.kt

@@ -2,19 +2,19 @@ package org.vestifeed.sync
 
 import android.util.Log
 import kotlinx.coroutines.Dispatchers
-import org.vestifeed.entries.EntriesRepo
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.withContext
 import org.vestifeed.api.Api
 import org.vestifeed.db.Database
 import java.time.Instant
+import java.time.OffsetDateTime
 
 class Sync(
     private val api: Api,
     private val db: Database,
-    private val entriesRepo: EntriesRepo,
 ) {
     sealed class State {
         object Idle : State()
@@ -60,7 +60,7 @@ class Sync(
             Log.d("sync", "syncing entries")
 
             runCatching {
-                entriesRepo.syncAll().collect { progress ->
+                syncAllEntries().collect { progress ->
                     var message = "Fetching news"
 
                     if (progress.itemsSynced > 0) {
@@ -93,7 +93,7 @@ class Sync(
 
             if (args.syncFlags) {
                 runCatching {
-                    entriesRepo.syncReadEntries()
+                    syncReadEntries()
                 }.onFailure {
                     _state.update { State.Idle }
                     return SyncResult.Failure(
@@ -105,7 +105,7 @@ class Sync(
                 }
 
                 runCatching {
-                    entriesRepo.syncBookmarkedEntries()
+                    syncBookmarkedEntries()
                 }.onFailure {
                     _state.update { State.Idle }
                     return SyncResult.Failure(
@@ -136,7 +136,7 @@ class Sync(
 
             return if (args.syncEntries) {
                 runCatching {
-                    val newAndUpdatedEntries = entriesRepo.syncNewAndUpdated(
+                    val newAndUpdatedEntries = syncNewAndUpdatedEntries(
                         lastEntriesSyncDateTime = db.conf.select().lastEntriesSyncDatetime,
                     )
 
@@ -191,4 +191,127 @@ class Sync(
         }
         Log.d("sync", "returning")
     }
+
+    fun syncAllEntries(): Flow<SyncProgress> = kotlinx.coroutines.flow.flow {
+        emit(SyncProgress(0L))
+
+        var entriesLoaded = 0L
+        emit(SyncProgress(entriesLoaded))
+
+        api.getEntries(false).collect { batch ->
+            entriesLoaded += batch.getOrThrow().size
+            emit(SyncProgress(entriesLoaded))
+            db.transaction {
+                db.entry.insertOrReplace(batch.getOrThrow())
+            }
+        }
+    }
+
+    suspend fun syncReadEntries() {
+        withContext(Dispatchers.IO) {
+            val unsyncedEntries = db.entry.selectByReadSynced(false)
+
+            if (unsyncedEntries.isEmpty()) {
+                return@withContext
+            }
+
+            val unsyncedReadEntries = unsyncedEntries.filter { it.extRead }
+
+            if (unsyncedReadEntries.isNotEmpty()) {
+                api.markEntriesAsRead(
+                    entriesIds = unsyncedReadEntries.map { it.id },
+                    read = true,
+                )
+
+                db.transaction {
+                    unsyncedReadEntries.forEach {
+                        db.entry.updateReadSynced(true, it.id)
+                    }
+                }
+            }
+
+            val unsyncedUnreadEntries = unsyncedEntries.filter { !it.extRead }
+
+            if (unsyncedUnreadEntries.isNotEmpty()) {
+                api.markEntriesAsRead(
+                    entriesIds = unsyncedUnreadEntries.map { it.id },
+                    read = false,
+                )
+
+                db.transaction {
+                    unsyncedUnreadEntries.forEach {
+                        db.entry.updateReadSynced(true, it.id)
+                    }
+                }
+            }
+        }
+    }
+
+    suspend fun syncBookmarkedEntries() {
+        withContext(Dispatchers.IO) {
+            val notSyncedEntries = db.entry.selectByBookmarkedSynced(false)
+
+            if (notSyncedEntries.isEmpty()) {
+                return@withContext
+            }
+
+            val notSyncedBookmarkedEntries = notSyncedEntries.filter { it.extBookmarked }
+
+            if (notSyncedBookmarkedEntries.isNotEmpty()) {
+                api.markEntriesAsBookmarked(notSyncedBookmarkedEntries, true)
+
+                db.transaction {
+                    notSyncedBookmarkedEntries.forEach {
+                        db.entry.updateBookmarkedSynced(true, it.id)
+                    }
+                }
+            }
+
+            val notSyncedNotBookmarkedEntries = notSyncedEntries.filterNot { it.extBookmarked }
+
+            if (notSyncedNotBookmarkedEntries.isNotEmpty()) {
+                api.markEntriesAsBookmarked(notSyncedNotBookmarkedEntries, false)
+
+                db.transaction {
+                    notSyncedNotBookmarkedEntries.forEach {
+                        db.entry.updateBookmarkedSynced(true, it.id)
+                    }
+                }
+            }
+        }
+    }
+
+    suspend fun syncNewAndUpdatedEntries(
+        lastEntriesSyncDateTime: String,
+    ): Int {
+        return withContext(Dispatchers.IO) {
+            val lastSyncInstant = if (lastEntriesSyncDateTime.isNotBlank()) {
+                OffsetDateTime.parse(lastEntriesSyncDateTime)
+            } else {
+                null
+            }
+
+            val maxUpdated = db.entry.selectMaxUpdated()
+
+            val maxUpdatedInstant = if (maxUpdated != null) {
+                OffsetDateTime.parse(maxUpdated)
+            } else {
+                null
+            }
+
+            val entries = api.getNewAndUpdatedEntries(
+                lastSync = lastSyncInstant,
+                maxEntryId = db.entry.selectMaxId(),
+                maxEntryUpdated = maxUpdatedInstant,
+            ).getOrThrow()
+
+            db.transaction {
+                db.entry.insertOrReplace(entries)
+            }
+
+            entries.size
+        }
+    }
+
+    data class SyncProgress(val itemsSynced: Long)
 }