More debugging. Source adding is still broken. Needs DB integration.

2022-05-21 22:05:11 +02:00
parent 6e38e8753c
commit 4c69e72499
18 changed files with 247 additions and 327 deletions
--- a/shared/src/commonMain/kotlin/bou/amine/apps/readerforselfossv2/rest/SelfossApi.kt
+++ b/shared/src/commonMain/kotlin/bou/amine/apps/readerforselfossv2/rest/SelfossApi.kt
@ -7,6 +7,7 @@ import io.ktor.client.engine.*
 import io.ktor.client.engine.ProxyBuilder.http
 import io.ktor.client.plugins.auth.*
 import io.ktor.client.plugins.auth.providers.*
+import io.ktor.client.plugins.cache.*
 import io.ktor.client.request.*
 import io.ktor.client.request.forms.*
 import io.ktor.http.*
@ -19,6 +20,7 @@ class SelfossApi(private val apiDetailsService: ApiDetailsService) {

    private val client = HttpClient() {
        install(ContentNegotiation) {
+            install(HttpCache)
            json(Json {
                prettyPrint = true
                isLenient = true
@ -100,7 +102,7 @@ class SelfossApi(private val apiDetailsService: ApiDetailsService) {
            }.body()

    suspend fun spouts(): Map<String, SelfossModel.Spout>? =
-        client.get(url("/a/spouts")) {
+        client.get(url("/sources/spouts")) {
                parameter("username", apiDetailsService.getUserName())
                parameter("password", apiDetailsService.getPassword())
            }.body()
@ -115,55 +117,38 @@ class SelfossApi(private val apiDetailsService: ApiDetailsService) {
        client.get(url("/api/about")).body()

    suspend fun markAsRead(id: String): SelfossModel.SuccessResponse? =
-        client.submitForm(
-                url = url("/mark/$id"),
-                formParameters = Parameters.build {
-                    append("username", apiDetailsService.getUserName())
-                    append("password", apiDetailsService.getPassword())
-                },
-                encodeInQuery = true
-            ).body()
+        client.post(url("/mark/$id")) {
+            parameter("username", apiDetailsService.getUserName())
+            parameter("password", apiDetailsService.getPassword())
+        }.body()

    suspend fun unmarkAsRead(id: String): SelfossModel.SuccessResponse? =
-        client.submitForm(
-                url = url("/unmark/$id"),
-                formParameters = Parameters.build {
-                    append("username", apiDetailsService.getUserName())
-                    append("password", apiDetailsService.getPassword())
-                },
-                encodeInQuery = true
-            ).body()
+        client.post(url("/unmark/$id")) {
+            parameter("username", apiDetailsService.getUserName())
+            parameter("password", apiDetailsService.getPassword())
+        }.body()

    suspend fun starr(id: String): SelfossModel.SuccessResponse? =
-        client.submitForm(
-                url = url("/starr/$id"),
-                formParameters = Parameters.build {
-                    append("username", apiDetailsService.getUserName())
-                    append("password", apiDetailsService.getPassword())
-                },
-                encodeInQuery = true
-            ).body()
+        client.post(url("/starr/$id")) {
+            parameter("username", apiDetailsService.getUserName())
+            parameter("password", apiDetailsService.getPassword())
+        }.body()

    suspend fun unstarr(id: String): SelfossModel.SuccessResponse? =
-        client.submitForm(
-                url = url("/unstarr/$id"),
-                formParameters = Parameters.build {
-                    append("username", apiDetailsService.getUserName())
-                    append("password", apiDetailsService.getPassword())
-                },
-                encodeInQuery = true
-            ).body()
+        client.post(url("/unstarr/$id")) {
+            parameter("username", apiDetailsService.getUserName())
+            parameter("password", apiDetailsService.getPassword())
+        }.body()

    suspend fun markAllAsRead(ids: List<String>): SelfossModel.SuccessResponse? =
        client.submitForm(
-                url = url("/mark"),
-                formParameters = Parameters.build {
-                    append("username", apiDetailsService.getUserName())
-                    append("password", apiDetailsService.getPassword())
-                    append("ids[]", ids.joinToString(","))
-                },
-                encodeInQuery = true
-            ).body()
+            url = url("/mark"),
+            formParameters = Parameters.build {
+                append("username", apiDetailsService.getUserName())
+                append("password", apiDetailsService.getPassword())
+                ids.map { append("ids[]", it) }
+            }
+        ).body()

    suspend fun createSourceForVersion(
        title: String,
@ -186,19 +171,15 @@ class SelfossApi(private val apiDetailsService: ApiDetailsService) {
        tags: String,
        filter: String
    ): SelfossModel.SuccessResponse? =
-        client.submitForm(
-                url = url("/source"),
-                formParameters = Parameters.build {
-                    append("username", apiDetailsService.getUserName())
-                    append("password", apiDetailsService.getPassword())
-                    append("title", title)
-                    append("url", url)
-                    append("spout", spout)
-                    append("tags", tags)
-                    append("filter", filter)
-                },
-                encodeInQuery = true
-            ).body()
+        client.post(url("/source")) {
+            parameter("username", apiDetailsService.getUserName())
+            parameter("password", apiDetailsService.getPassword())
+            parameter("title", title)
+            parameter("url", url)
+            parameter("spout", spout)
+            parameter("tags", tags)
+            parameter("filter", filter)
+        }.body()

    private suspend fun createSource2(
        title: String,
@ -207,21 +188,17 @@ class SelfossApi(private val apiDetailsService: ApiDetailsService) {
        tags: String,
        filter: String
    ): SelfossModel.SuccessResponse? =
-        client.submitForm(
-                url = url("/source"),
-                formParameters = Parameters.build {
-                    append("username", apiDetailsService.getUserName())
-                    append("password", apiDetailsService.getPassword())
-                    append("title", title)
-                    append("url", url)
-                    append("spout", spout)
-                    append("tags[]", tags)
-                    append("filter", filter)
-                },
-                encodeInQuery = true
-            ).body()
+        client.post(url("/source")) {
+            parameter("username", apiDetailsService.getUserName())
+            parameter("password", apiDetailsService.getPassword())
+            parameter("title", title)
+            parameter("url", url)
+            parameter("spout", spout)
+            parameter("tags[]", tags)
+            parameter("filter", filter)
+        }.body()

-    suspend fun deleteSource(id: String): SelfossModel.SuccessResponse? =
+    suspend fun deleteSource(id: Int): SelfossModel.SuccessResponse? =
        client.delete(url("/source/$id")) {
                parameter("username", apiDetailsService.getUserName())
                parameter("password", apiDetailsService.getPassword())
--- a/shared/src/commonMain/kotlin/bou/amine/apps/readerforselfossv2/rest/SelfossModel.kt
+++ b/shared/src/commonMain/kotlin/bou/amine/apps/readerforselfossv2/rest/SelfossModel.kt
@ -52,7 +52,7 @@ class SelfossModel {

    @Serializable
    data class Source(
-        val id: String,
+        val id: Int,
        val title: String,
        val tags: List<String>,
        val spout: String,
@ -62,16 +62,16 @@ class SelfossModel {

    @Serializable
    data class Item(
-        val id: String,
+        val id: Int,
        val datetime: String,
        val title: String,
        val content: String,
-        var unread: Int,
-        var starred: Int,
+        var unread: Boolean,
+        var starred: Boolean,
        val thumbnail: String?,
        val icon: String?,
        val link: String,
        val sourcetitle: String,
-        val tags: String
+        val tags: List<String>
    )
 }
--- a/shared/src/commonMain/kotlin/bou/amine/apps/readerforselfossv2/service/DeviceDataBaseService.kt
+++ b/shared/src/commonMain/kotlin/bou/amine/apps/readerforselfossv2/service/DeviceDataBaseService.kt
@ -27,8 +27,8 @@ abstract class DeviceDataBaseService<ItemEntity>(val db: DeviceDatabase<ItemEnti
    // This filtered items from items val. Do not use
    fun getFocusedItems() {}
    fun computeBadges() {
-        searchService.badgeUnread = items.filter { item -> item.unread == 1 }.size
-        searchService.badgeStarred = items.filter { item -> item.starred == 1 }.size
+        searchService.badgeUnread = items.filter { item -> item.unread }.size
+        searchService.badgeStarred = items.filter { item -> item.starred }.size
        searchService.badgeAll = items.size
    }
 }
--- a/shared/src/commonMain/kotlin/bou/amine/apps/readerforselfossv2/service/SearchService.kt
+++ b/shared/src/commonMain/kotlin/bou/amine/apps/readerforselfossv2/service/SearchService.kt
@ -21,10 +21,6 @@ class SearchService(val dateUtils: DateUtils) {
    var tagFilter: String? = null
    var itemsCaching = false

-    var fetchedUnread = false
-    var fetchedAll = false
-    var fetchedStarred = false
-
    var badgeUnread = -1
    var badgeAll = -1
    var badgeStarred = -1
--- a/shared/src/commonMain/kotlin/bou/amine/apps/readerforselfossv2/service/SelfossService.kt
+++ b/shared/src/commonMain/kotlin/bou/amine/apps/readerforselfossv2/service/SelfossService.kt
@ -7,90 +7,48 @@ import kotlinx.coroutines.*

 class SelfossService<ItemEntity>(val api: SelfossApi, private val dbService: DeviceDataBaseService<ItemEntity>, private val searchService: SearchService) {

-    suspend fun getAndStoreAllItems(isNetworkAvailable: Boolean) = withContext(
+    suspend fun getReadItems(itemsNumber: Int, offset: Int, isNetworkAvailable: Boolean): List<SelfossModel.Item>? = withContext(
        Dispatchers.Default) {
        if (isNetworkAvailable) {
-            launch {
-                try {
-                    enqueueArticles(allNewItems(), true)
-                } catch (e: Throwable) {}
-            }
-            launch {
-                try {
-                    enqueueArticles(allReadItems(), false)
-                } catch (e: Throwable) {}
-            }
-            launch {
-                try {
-                    enqueueArticles(allStarredItems(), false)
-                } catch (e: Throwable) {}
-            }
+            val apiItems = readItems( itemsNumber, offset)
+            // SAVE OR UPDATE IN DB
+            return@withContext apiItems
        } else {
-            launch { dbService.updateDatabase() }
+            // GET FROM DB
+            return@withContext emptyList()
        }
    }

-    suspend fun refreshFocusedItems(itemsNumber: Int, isNetworkAvailable: Boolean) = withContext(
+    suspend fun getUnreadItems(itemsNumber: Int, offset: Int, isNetworkAvailable: Boolean): List<SelfossModel.Item>? = withContext(
        Dispatchers.Default) {
        if (isNetworkAvailable) {
-            val response = when (searchService.displayedItems) {
-                "read" -> readItems(itemsNumber, 0)
-                "unread" -> newItems(itemsNumber, 0)
-                "starred" -> starredItems(itemsNumber, 0)
-                else -> readItems(itemsNumber, 0)
-            }
-
-            if (response != null) {
-                // TODO:
-                // dbService.refreshFocusedItems(response.body() as ArrayList<SelfossModel.Item>)
-                dbService.updateDatabase()
-            }
+            val apiItems = newItems(itemsNumber, offset)
+            // SAVE OR UPDATE IN DB
+            return@withContext apiItems
+        } else {
+            // GET FROM DB
+            return@withContext emptyList()
        }
    }

-    suspend fun getReadItems(itemsNumber: Int, offset: Int, isNetworkAvailable: Boolean) = withContext(
+    suspend fun getStarredItems(itemsNumber: Int, offset: Int, isNetworkAvailable: Boolean): List<SelfossModel.Item>? = withContext(
        Dispatchers.Default) {
        if (isNetworkAvailable) {
-            try {
-                enqueueArticles(readItems( itemsNumber, offset), false)
-                searchService.fetchedAll = true
-                dbService.updateDatabase()
-            } catch (e: Throwable) {}
+            val apiItems = starredItems(itemsNumber, offset)
+            // SAVE OR UPDATE IN DB
+            return@withContext apiItems
+        } else {
+            // GET FROM DB
+            return@withContext emptyList()
        }
    }

-    suspend fun getUnreadItems(itemsNumber: Int, offset: Int, isNetworkAvailable: Boolean) = withContext(
-        Dispatchers.Default) {
-        if (isNetworkAvailable) {
-            try {
-                if (!searchService.fetchedUnread) {
-                    dbService.clearDBItems()
-                }
-                enqueueArticles(newItems(itemsNumber, offset), false)
-                searchService.fetchedUnread = true
-            } catch (e: Throwable) {}
-        }
-        dbService.updateDatabase()
-    }
-
-    suspend fun getStarredItems(itemsNumber: Int, offset: Int, isNetworkAvailable: Boolean) = withContext(
-        Dispatchers.Default) {
-        if (isNetworkAvailable) {
-            try {
-                enqueueArticles(starredItems(itemsNumber, offset), false)
-                searchService.fetchedStarred = true
-                dbService.updateDatabase()
-            } catch (e: Throwable) {
-            }
-        }
-    }
-
-    suspend fun readAll(isNetworkAvailable: Boolean): Boolean {
+    suspend fun readAll(ids: List<String>, isNetworkAvailable: Boolean): Boolean {
+        // Add ids params
        var success = false
        if (isNetworkAvailable) {
-          // Do api call to read all
-        } else {
-            // Do db call to read all
+          success = api.markAllAsRead(ids)?.isSuccess == true
+            // SAVE OR UPDATE IN DB
        }
        // refresh view
        return success
@ -100,7 +58,6 @@ class SelfossService<ItemEntity>(val api: SelfossApi, private val dbService: Dev
        if (isNetworkAvailable) {
            try {
                val response = api.stats()
-
                if (response != null) {
                    searchService.badgeUnread = response.unread
                    searchService.badgeAll = response.total
@ -123,13 +80,13 @@ class SelfossService<ItemEntity>(val api: SelfossApi, private val dbService: Dev
        }
    }

-    private suspend fun allNewItems(): List<SelfossModel.Item>? =
+    suspend fun allNewItems(): List<SelfossModel.Item>? =
        readItems(200, 0)

-    private suspend fun allReadItems(): List<SelfossModel.Item>? =
+    suspend fun allReadItems(): List<SelfossModel.Item>? =
        newItems(200, 0)

-    private suspend fun allStarredItems(): List<SelfossModel.Item>? =
+    suspend fun allStarredItems(): List<SelfossModel.Item>? =
        starredItems(200, 0)

    private suspend fun readItems(