fix WebUI release name

* Document all endpoints

* Forgot about global endpoints

CHANGELOG.md

@@ -1,3 +1,67 @@
+# Server: v0.6.3-next + WebUI: r944
+## TL;DR
+- N/A
+
+## Tachidesk-Server Changelog
+- (r1087) v0.6.3 (by @AriaMoradi)
+- (r1088) Save categories when manga is unfavorited ([#335](https://github.com/Suwayomi/Tachidesk-Server/pull/335) by @Syer10)
+- (r1089) handle solid RAR archives ([#339](https://github.com/Suwayomi/Tachidesk-Server/pull/339)) cfso100@gmail.com
+- (r1090) add support for changing downloads dir ([#343](https://github.com/Suwayomi/Tachidesk-Server/pull/343) by @AriaMoradi)
+- (r1091) fix Applications dir dependency ([#344](https://github.com/Suwayomi/Tachidesk-Server/pull/344) by @AriaMoradi)
+- (r1092) add support for alternative web interfaces ([#342](https://github.com/Suwayomi/Tachidesk-Server/pull/342) by @AriaMoradi)
+- (r1093) Add displayValues json field for select filter ([#347](https://github.com/Suwayomi/Tachidesk-Server/pull/347) by @Syer10)
+- (r1094) document manga endpoints ([#348](https://github.com/Suwayomi/Tachidesk-Server/pull/348) by @Syer10)
+- (r1095) add ChapterCount to manga object in categoryMangas endpoint ([#349](https://github.com/Suwayomi/Tachidesk-Server/pull/349) by @abhijeetChawla)
+- (r1096) document all endpoints ([#350](https://github.com/Suwayomi/Tachidesk-Server/pull/350) by @Syer10)
+- (r1097) fix copymanga ([#354](https://github.com/Suwayomi/Tachidesk-Server/pull/354) by @AriaMoradi)
+- (r1098) fix formatting by kotlinter (by @AriaMoradi)
+
+## Tachidesk-WebUI Changelog
+- (r943) fix default width ([#171](https://github.com/Suwayomi/Tachidesk-WebUI/pull/171) by @Robonau)
+- (r944) added an update checker button for library ([#172](https://github.com/Suwayomi/Tachidesk-WebUI/pull/172) by @infix)
+
+# Server: v0.6.3 + WebUI: r942
+## TL;DR
+- Changes in Server
+    - Support for array search filter changes list
+    - Support for Tachiyomi extensions lib 1.3
+- Changes in WebUI
+    - Better search filter support
+    - Fluid manga grid
+    - Library comfortable grid
+    - Sources view layouts
+    - Various other changes...
+
+## Tachidesk-Server Changelog
+- (r1074) v0.6.2 (by @AriaMoradi)
+- (r1075) support array filter changes ([#304](https://github.com/Suwayomi/Tachidesk-Server/pull/304) by @AriaMoradi)
+- (r1076) fix filterlist bugs ([#306](https://github.com/Suwayomi/Tachidesk-Server/pull/306) by @AriaMoradi)
+- (r1077) Update README.md ([#305](https://github.com/Suwayomi/Tachidesk-Server/pull/305) by @mahor1221)
+- (r1078) fix meta update changing all keys ([#314](https://github.com/Suwayomi/Tachidesk-Server/pull/314) by @AriaMoradi)
+- (r1079) add support for tachiyomi extensions Lib 1.3 ([#316](https://github.com/Suwayomi/Tachidesk-Server/pull/316) by @AriaMoradi)
+- (r1080) Fix sources list of one source throws an exception ([#308](https://github.com/Suwayomi/Tachidesk-Server/pull/308) by @Syer10)
+- (r1081) Improve source handling, fix errors with uninitialized mangas in broken sources ([#319](https://github.com/Suwayomi/Tachidesk-Server/pull/319) by @Syer10)
+- (r1082) Add thumbnail support for stub sources ([#320](https://github.com/Suwayomi/Tachidesk-Server/pull/320) by @Syer10)
+- (r1083) update description for Tachidesk-Sorayomi ([#326](https://github.com/Suwayomi/Tachidesk-Server/pull/326) by @DattatreyaReddy)
+- (r1084) Add last bit of code needed for Extensions Lib 1.3 ([#330](https://github.com/Suwayomi/Tachidesk-Server/pull/330) by @Syer10)
+- (r1085) Add QuickJS, replaces Duktape for Extensions Lib 1.3 ([#331](https://github.com/Suwayomi/Tachidesk-Server/pull/331) by @Syer10)
+- (r1086) fix auth not actually blocking requests ([#333](https://github.com/Suwayomi/Tachidesk-Server/pull/333) by @AriaMoradi)
+
+## Tachidesk-WebUI Changelog
+- (r930) Source filter scroll fix (array of filters on submit [#149](https://github.com/Suwayomi/Tachidesk-WebUI/pull/149) by @Robonau)
+- (r931) fix manga badges setting menu that turns the update/download badges on and off ([#150](https://github.com/Suwayomi/Tachidesk-WebUI/pull/150) by @Robonau)
+- (r932) move sorts to copy tachiyomi ([#151](https://github.com/Suwayomi/Tachidesk-WebUI/pull/151) by @Robonau)
+- (r933) add comfortable grid option ([#152](https://github.com/Suwayomi/Tachidesk-WebUI/pull/152) by @Robonau)
+- (r934) source layouts ([#153](https://github.com/Suwayomi/Tachidesk-WebUI/pull/153) by @Robonau)
+- (r935) List layout ([#154](https://github.com/Suwayomi/Tachidesk-WebUI/pull/154) by @Robonau)
+- (r936) in library badge to manga in sources ([#156](https://github.com/Suwayomi/Tachidesk-WebUI/pull/156) by @Robonau)
+- (r937) mass search ([#157](https://github.com/Suwayomi/Tachidesk-WebUI/pull/157) by @Robonau)
+- (r938) 18+ tag on source/extension cards ([#160](https://github.com/Suwayomi/Tachidesk-WebUI/pull/160) by @Robonau)
+- (r939) fix search source click ([#164](https://github.com/Suwayomi/Tachidesk-WebUI/pull/164) by @Robonau)
+- (r940) items per row setting ([#165](https://github.com/Suwayomi/Tachidesk-WebUI/pull/165) by @Robonau)
+- (r941) fix the grid width thing ([#169](https://github.com/Suwayomi/Tachidesk-WebUI/pull/169) by @Robonau)
+- (r942) unified library options ([#168](https://github.com/Suwayomi/Tachidesk-WebUI/pull/168) by @infix)
+
 # Server: v0.6.2 + WebUI: r929
 ## TL;DR
 - Changes in WebUI

README.md

@@ -49,7 +49,7 @@ Here's a list of known clients/user interfaces for Tachidesk-Server:
 - [Tachidesk-WebUI](https://github.com/Suwayomi/Tachidesk-WebUI): The web/ElectronJS front-end that Tachidesk-Server is traditionally shipped with. Usually gets new features faster.
 - [Tachidesk-JUI](https://github.com/Suwayomi/Tachidesk-JUI): The native desktop front-end for Tachidesk-Server. Currently the most advanced.
 - [Tachidesk-qtui](https://github.com/Suwayomi/Tachidesk-qtui): A C++/Qt front-end for mobile devices(Android/linux), in super early stage of development. 
-- [Tachidesk-Flutter](https://github.com/Suwayomi/Tachidesk-Flutter): A Flutter front-end for Desktop(Linux, windows, etc.), in early stage of development. 
+- [Tachidesk-Sorayomi](https://github.com/Suwayomi/Tachidesk-Sorayomi): A Flutter front-end for Desktop(Linux, windows, etc.), Web and Android. UI and UX similar to Tachiyomi.
 ##### Inctive/Abandoned Cients
 - [Equinox](https://github.com/Suwayomi/Equinox): A web user interface made with Vue.js, in super early stage of development.
 - [Tachidesk-GTK](https://github.com/mahor1221/Tachidesk-GTK): A native Rust/GTK desktop client, in super early stage of development.
@@ -80,33 +80,40 @@ If a bundle for your operating system or cpu architecture is not provided then r
 **Node:** Linux launcher scripts are named a bit differently but work the same. 
 
 ### Windows
-Download the latest `win32`(Windows 32-bit) or `win64`(Windows 64-bit) release from [the releases section](https://github.com/Suwayomi/Tachidesk/releases) or a preview one from [the preview repository](https://github.com/Suwayomi/Tachidesk-preview/releases).
+Download the latest `win32`(Windows 32-bit) or `win64`(Windows 64-bit) release from [the releases section](https://github.com/Suwayomi/Tachidesk-Server/releases) or a preview one from [the preview repository](https://github.com/Suwayomi/Tachidesk-Server-preview/releases).
 
 Unzip the downloaded file and double click on one of the launcher scripts.
 
 ### macOS
-Download the latest `macOS-x64`(older macOS systems) or `macOS-arm64`(Apple M1) release from [the releases section](https://github.com/Suwayomi/Tachidesk/releases) or a preview one from [the preview repository](https://github.com/Suwayomi/Tachidesk-preview/releases).
+Download the latest `macOS-x64`(older macOS systems) or `macOS-arm64`(Apple M1) release from [the releases section](https://github.com/Suwayomi/Tachidesk-Server/releases) or a preview one from [the preview repository](https://github.com/Suwayomi/Tachidesk-Server-preview/releases).
 
 Unzip the downloaded file and double click on one of the launcher scripts.
 
 ### GNU/Linux
-Download the latest `linux-x64`(x86_64) release from [the releases section](https://github.com/Suwayomi/Tachidesk/releases) or a preview one from [the preview repository](https://github.com/Suwayomi/Tachidesk-preview/releases).
+Download the latest `linux-x64`(x86_64) release from [the releases section](https://github.com/Suwayomi/Tachidesk-Server/releases) or a preview one from [the preview repository](https://github.com/Suwayomi/Tachidesk-Server-preview/releases).
 
 `tar xvf` the downloaded file and double click on one of the launcher scripts or run them using the terminal.
 
 ## Other methods of getting Tachidesk
 ### Arch Linux
-You can install Tachidesk from the AUR
+You can install Tachidesk from the AUR:
 ```
 yay -S tachidesk
 ```
 
-### Ubuntu-based distributions
+### Debian/Ubuntu
-More information can be found on the [PPA's page](https://launchpad.net/~suwayomi/+archive/ubuntu/tachidesk).
+Download the latest deb package from the release section or Install from the MPR
 ```
-sudo add-apt-repository ppa:suwayomi/tachidesk
+git clone https://mpr.makedeb.org/tachidesk-server.git
+cd tachidesk-server
+makedeb -si
+```
+
+### Ubuntu
+```
+sudo add-apt-repository ppa:suwayomi/tachidesk-server
 sudo apt update
-sudo apt install tachidesk
+sudo apt install tachidesk-server
 ```
 
 ### Docker

buildSrc/src/main/kotlin/Constants.kt

@@ -12,9 +12,10 @@ const val kotlinVersion = "1.6.10"
 const val MainClass = "suwayomi.tachidesk.MainKt"
 
 // should be bumped with each stable release
-val tachideskVersion = System.getenv("ProductVersion") ?: "v0.6.2"
+val tachideskVersion = System.getenv("ProductVersion") ?: "v0.6.3"
 
-val webUIRevisionTag = System.getenv("WebUIRevision") ?: "r929"
+val webUIRevisionTag = System.getenv("WebUIRevision") ?: "r944"
+val sorayomiRevisionTag = System.getenv("SorayomiRevision") ?: "0.1.5"
 
 // counts commits on the master branch
 val tachideskRevision = runCatching {

server/build.gradle.kts

@@ -44,6 +44,7 @@ dependencies {
     implementation("com.squareup.okhttp3:okhttp:$okhttpVersion")
     implementation("io.reactivex:rxjava:1.3.8")
     implementation("org.jsoup:jsoup:1.14.3")
+    implementation("app.cash.quickjs:quickjs-jvm:0.9.2")
 
     // Sort
     implementation("com.github.gpanther:java-nat-sort:natural-comparator-1.1")
@@ -53,11 +54,14 @@ dependencies {
 
     // Disk & File
     implementation("net.lingala.zip4j:zip4j:2.9.1")
-    implementation("com.github.junrar:junrar:7.4.0")
+    implementation("com.github.junrar:junrar:7.5.0")
 
     // CloudflareInterceptor
     implementation("net.sourceforge.htmlunit:htmlunit:2.56.0")
 
+    // AES/CBC/PKCS7Padding Cypher provider for zh.copymanga
+    implementation("org.bouncycastle:bcprov-jdk18on:1.71")
+
     // Source models and interfaces from Tachiyomi 1.x
     // using source class from tachiyomi commit 9493577de27c40ce8b2b6122cc447d025e34c477 to not depend on tachiyomi.sourceapi
 //    implementation("tachiyomi.sourceapi:source-api:1.1")
@@ -74,6 +78,9 @@ dependencies {
 }
 
 application {
+    applicationDefaultJvmArgs = listOf(
+        "-Djunrar.extractor.thread-keep-alive-seconds=30"
+    )
     mainClass.set(MainClass)
 }
 
@@ -103,6 +110,9 @@ buildConfig {
     buildConfigField("String", "WEBUI_REPO", quoteWrap("https://github.com/Suwayomi/Tachidesk-WebUI-preview"))
     buildConfigField("String", "WEBUI_TAG", quoteWrap(webUIRevisionTag))
 
+    buildConfigField("String", "SORAYOMI_REPO", quoteWrap("https://github.com/Suwayomi/Tachidesk-Sorayomi"))
+    buildConfigField("String", "SORAYOMI_TAG", quoteWrap(sorayomiRevisionTag))
+
 
     buildConfigField("String", "GITHUB", quoteWrap("https://github.com/Suwayomi/Tachidesk-Server"))
     buildConfigField("String", "DISCORD", quoteWrap("https://discord.gg/DDZdqZWaHA"))

server/src/main/java/eu/kanade/tachiyomi/BuildConfig.java

@@ -0,0 +1,9 @@
+package eu.kanade.tachiyomi;
+
+public class BuildConfig {
+    /** should be something like 74 */
+    public static final int VERSION_CODE = Integer.parseInt(suwayomi.tachidesk.server.BuildConfig.REVISION.substring(1));
+
+    /** should be something like "0.13.1" */
+    public static final String VERSION_NAME = suwayomi.tachidesk.server.BuildConfig.VERSION.substring(1);
+}

server/src/main/kotlin/eu/kanade/tachiyomi/AppInfo.kt

@@ -0,0 +1,11 @@
+package eu.kanade.tachiyomi
+
+/**
+ * Used by extensions.
+ *
+ * @since extension-lib 1.3
+ */
+object AppInfo {
+    fun getVersionCode() = BuildConfig.VERSION_CODE
+    fun getVersionName() = BuildConfig.VERSION_NAME
+}

server/src/main/kotlin/eu/kanade/tachiyomi/BuildConfig.java

@@ -1,6 +0,0 @@
-package eu.kanade.tachiyomi;
-
-public class BuildConfig {
-    public static final int VERSION_CODE = -1;
-    public static final String VERSION_NAME = "stub";
-}

server/src/main/kotlin/eu/kanade/tachiyomi/network/interceptor/RateLimitInterceptor.kt

@@ -0,0 +1,67 @@
+package eu.kanade.tachiyomi.network.interceptor
+
+import android.os.SystemClock
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+import okhttp3.Response
+import java.util.concurrent.TimeUnit
+
+/**
+ * An OkHttp interceptor that handles rate limiting.
+ *
+ * Examples:
+ *
+ * permits = 5,  period = 1, unit = seconds  =>  5 requests per second
+ * permits = 10, period = 2, unit = minutes  =>  10 requests per 2 minutes
+ *
+ * @since extension-lib 1.3
+ *
+ * @param permits {Int}   Number of requests allowed within a period of units.
+ * @param period {Long}   The limiting duration. Defaults to 1.
+ * @param unit {TimeUnit} The unit of time for the period. Defaults to seconds.
+ */
+fun OkHttpClient.Builder.rateLimit(
+    permits: Int,
+    period: Long = 1,
+    unit: TimeUnit = TimeUnit.SECONDS,
+) = addInterceptor(RateLimitInterceptor(permits, period, unit))
+
+private class RateLimitInterceptor(
+    private val permits: Int,
+    period: Long,
+    unit: TimeUnit,
+) : Interceptor {
+
+    private val requestQueue = ArrayList<Long>(permits)
+    private val rateLimitMillis = unit.toMillis(period)
+
+    override fun intercept(chain: Interceptor.Chain): Response {
+        synchronized(requestQueue) {
+            val now = SystemClock.elapsedRealtime()
+            val waitTime = if (requestQueue.size < permits) {
+                0
+            } else {
+                val oldestReq = requestQueue[0]
+                val newestReq = requestQueue[permits - 1]
+
+                if (newestReq - oldestReq > rateLimitMillis) {
+                    0
+                } else {
+                    oldestReq + rateLimitMillis - now // Remaining time
+                }
+            }
+
+            if (requestQueue.size == permits) {
+                requestQueue.removeAt(0)
+            }
+            if (waitTime > 0) {
+                requestQueue.add(now + waitTime)
+                Thread.sleep(waitTime) // Sleep inside synchronized to pause queued requests
+            } else {
+                requestQueue.add(now)
+            }
+        }
+
+        return chain.proceed(chain.request())
+    }
+}

server/src/main/kotlin/eu/kanade/tachiyomi/network/interceptor/SpecificHostRateLimitInterceptor.kt

@@ -0,0 +1,75 @@
+package eu.kanade.tachiyomi.network.interceptor
+
+import android.os.SystemClock
+import okhttp3.HttpUrl
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+import okhttp3.Response
+import java.util.concurrent.TimeUnit
+
+/**
+ * An OkHttp interceptor that handles given url host's rate limiting.
+ *
+ * Examples:
+ *
+ * httpUrl = "api.manga.com".toHttpUrlOrNull(), permits = 5, period = 1, unit = seconds  =>  5 requests per second to api.manga.com
+ * httpUrl = "imagecdn.manga.com".toHttpUrlOrNull(), permits = 10, period = 2, unit = minutes  =>  10 requests per 2 minutes to imagecdn.manga.com
+ *
+ * @since extension-lib 1.3
+ *
+ * @param httpUrl {HttpUrl} The url host that this interceptor should handle. Will get url's host by using HttpUrl.host()
+ * @param permits {Int}   Number of requests allowed within a period of units.
+ * @param period {Long}   The limiting duration. Defaults to 1.
+ * @param unit {TimeUnit} The unit of time for the period. Defaults to seconds.
+ */
+fun OkHttpClient.Builder.rateLimitHost(
+    httpUrl: HttpUrl,
+    permits: Int,
+    period: Long = 1,
+    unit: TimeUnit = TimeUnit.SECONDS,
+) = addInterceptor(SpecificHostRateLimitInterceptor(httpUrl, permits, period, unit))
+
+class SpecificHostRateLimitInterceptor(
+    httpUrl: HttpUrl,
+    private val permits: Int,
+    period: Long,
+    unit: TimeUnit,
+) : Interceptor {
+
+    private val requestQueue = ArrayList<Long>(permits)
+    private val rateLimitMillis = unit.toMillis(period)
+    private val host = httpUrl.host
+
+    override fun intercept(chain: Interceptor.Chain): Response {
+        if (chain.request().url.host != host) {
+            return chain.proceed(chain.request())
+        }
+        synchronized(requestQueue) {
+            val now = SystemClock.elapsedRealtime()
+            val waitTime = if (requestQueue.size < permits) {
+                0
+            } else {
+                val oldestReq = requestQueue[0]
+                val newestReq = requestQueue[permits - 1]
+
+                if (newestReq - oldestReq > rateLimitMillis) {
+                    0
+                } else {
+                    oldestReq + rateLimitMillis - now // Remaining time
+                }
+            }
+
+            if (requestQueue.size == permits) {
+                requestQueue.removeAt(0)
+            }
+            if (waitTime > 0) {
+                requestQueue.add(now + waitTime)
+                Thread.sleep(waitTime) // Sleep inside synchronized to pause queued requests
+            } else {
+                requestQueue.add(now)
+            }
+        }
+
+        return chain.proceed(chain.request())
+    }
+}

server/src/main/kotlin/eu/kanade/tachiyomi/source/UnmeteredSource.kt

@@ -0,0 +1,8 @@
+package eu.kanade.tachiyomi.source
+
+/**
+ * A source that explicitly doesn't require traffic considerations.
+ *
+ * This typically applies for self-hosted sources.
+ */
+interface UnmeteredSource

server/src/main/kotlin/eu/kanade/tachiyomi/source/local/loader/RarPageLoader.kt

@@ -5,11 +5,10 @@ import com.github.junrar.rarfile.FileHeader
 import eu.kanade.tachiyomi.source.model.Page
 import eu.kanade.tachiyomi.util.lang.compareToCaseInsensitiveNaturalOrder
 import suwayomi.tachidesk.manga.impl.util.storage.ImageUtil
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.InputStream
-import java.io.PipedInputStream
-import java.io.PipedOutputStream
-import java.util.concurrent.Executors
 
 /**
  * Loader used to load a chapter from a .rar or .cbr file.
@@ -22,20 +21,40 @@ class RarPageLoader(file: File) : PageLoader {
     private val archive = Archive(file)
 
     /**
-     * Pool for copying compressed files to an input stream.
+     * The fully uncompressed files, to be used in case archive is solid.
      */
-    private val pool = Executors.newFixedThreadPool(1)
+    private var archiveMap = mutableMapOf<FileHeader, InputStream>()
 
     /**
      * Returns an observable containing the pages found on this rar archive ordered with a natural
      * comparator.
      */
     override fun getPages(): List<ReaderPage> {
+        if (archive.mainHeader.isSolid) {
+            // Solid means that we need to read all the file sequentially
+            for (header in archive.fileHeaders) {
+                val baos = ByteArrayOutputStream()
+                archive.extractFile(header, baos)
+                archiveMap[header] = ByteArrayInputStream(baos.toByteArray())
+            }
+            // After reading the full archive, proceed to filter and transform
+            return archive.fileHeaders
+                .filter { !it.isDirectory && ImageUtil.isImage(it.fileName) { archiveMap.getValue(it) } }
+                .sortedWith { f1, f2 -> f1.fileName.compareToCaseInsensitiveNaturalOrder(f2.fileName) }
+                .mapIndexed { i, header ->
+                    val streamFn = { archiveMap.getValue(header) }
+
+                    ReaderPage(i).apply {
+                        stream = streamFn
+                        status = Page.READY
+                    }
+                }
+        }
         return archive.fileHeaders
             .filter { !it.isDirectory && ImageUtil.isImage(it.fileName) { archive.getInputStream(it) } }
             .sortedWith { f1, f2 -> f1.fileName.compareToCaseInsensitiveNaturalOrder(f2.fileName) }
             .mapIndexed { i, header ->
-                val streamFn = { getStream(header) }
+                val streamFn = { archive.getInputStream(header) }
 
                 ReaderPage(i).apply {
                     stream = streamFn
@@ -43,21 +62,4 @@ class RarPageLoader(file: File) : PageLoader {
                 }
             }
     }
-
-    /**
-     * Returns an input stream for the given [header].
-     */
-    private fun getStream(header: FileHeader): InputStream {
-        val pipeIn = PipedInputStream()
-        val pipeOut = PipedOutputStream(pipeIn)
-        pool.execute {
-            try {
-                pipeOut.use {
-                    archive.extractFile(header, it)
-                }
-            } catch (e: Exception) {
-            }
-        }
-        return pipeIn
-    }
 }

server/src/main/kotlin/eu/kanade/tachiyomi/source/model/Filter.kt

@@ -5,7 +5,9 @@ package eu.kanade.tachiyomi.source.model
 open class Filter<T>(val name: String, var state: T) {
     open class Header(name: String) : Filter<Any>(name, 0)
     open class Separator(name: String = "") : Filter<Any>(name, 0)
-    abstract class Select<V>(name: String, val values: Array<V>, state: Int = 0) : Filter<Int>(name, state)
+    abstract class Select<V>(name: String, val values: Array<V>, state: Int = 0) : Filter<Int>(name, state) {
+        val displayValues get() = values.map { it.toString() }
+    }
     abstract class Text(name: String, state: String = "") : Filter<String>(name, state)
     abstract class CheckBox(name: String, state: Boolean = false) : Filter<Boolean>(name, state)
     abstract class TriState(name: String, state: Int = STATE_IGNORE) : Filter<Int>(name, state) {

server/src/main/kotlin/eu/kanade/tachiyomi/source/model/SManga.kt

@@ -55,6 +55,9 @@ interface SManga : Serializable {
         const val ONGOING = 1
         const val COMPLETED = 2
         const val LICENSED = 3
+        const val PUBLISHING_FINISHED = 4
+        const val CANCELLED = 5
+        const val ON_HIATUS = 6
 
         fun create(): SManga {
             return SMangaImpl()

server/src/main/kotlin/suwayomi/tachidesk/global/GlobalAPI.kt

@@ -14,8 +14,8 @@ import suwayomi.tachidesk.global.controller.SettingsController
 object GlobalAPI {
     fun defineEndpoints() {
         path("settings") {
-            get("about", SettingsController::about)
+            get("about", SettingsController.about)
-            get("check-update", SettingsController::checkUpdate)
+            get("check-update", SettingsController.checkUpdate)
         }
     }
 }

server/src/main/kotlin/suwayomi/tachidesk/global/controller/SettingsController.kt

@@ -7,22 +7,48 @@ package suwayomi.tachidesk.global.controller
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-import io.javalin.http.Context
+import io.javalin.http.HttpCode
 import suwayomi.tachidesk.global.impl.About
+import suwayomi.tachidesk.global.impl.AboutDataClass
 import suwayomi.tachidesk.global.impl.AppUpdate
+import suwayomi.tachidesk.global.impl.UpdateDataClass
 import suwayomi.tachidesk.server.JavalinSetup.future
+import suwayomi.tachidesk.server.util.handler
+import suwayomi.tachidesk.server.util.withOperation
 
 /** Settings Page/Screen */
 object SettingsController {
     /** returns some static info about the current app build */
-    fun about(ctx: Context) {
+    val about = handler(
-        ctx.json(About.getAbout())
+        documentWith = {
-    }
+            withOperation {
+                summary("About Tachidesk")
+                description("Returns some static info about the current app build")
+            }
+        },
+        behaviorOf = { ctx ->
+            ctx.json(About.getAbout())
+        },
+        withResults = {
+            json<AboutDataClass>(HttpCode.OK)
+        }
+    )
 
     /** check for app updates */
-    fun checkUpdate(ctx: Context) {
+    val checkUpdate = handler(
-        ctx.json(
+        documentWith = {
-            future { AppUpdate.checkUpdate() }
+            withOperation {
-        )
+                summary("Tachidesk update check")
-    }
+                description("Check for app updates")
+            }
+        },
+        behaviorOf = { ctx ->
+            ctx.json(
+                future { AppUpdate.checkUpdate() }
+            )
+        },
+        withResults = {
+            json<UpdateDataClass>(HttpCode.OK)
+        }
+    )
 }

server/src/main/kotlin/suwayomi/tachidesk/manga/MangaAPI.kt

@@ -24,98 +24,98 @@ import suwayomi.tachidesk.manga.controller.UpdateController
 object MangaAPI {
     fun defineEndpoints() {
         path("extension") {
-            get("list", ExtensionController::list)
+            get("list", ExtensionController.list)
 
-            get("install/{pkgName}", ExtensionController::install)
+            get("install/{pkgName}", ExtensionController.install)
-            post("install", ExtensionController::installFile)
+            post("install", ExtensionController.installFile)
-            get("update/{pkgName}", ExtensionController::update)
+            get("update/{pkgName}", ExtensionController.update)
-            get("uninstall/{pkgName}", ExtensionController::uninstall)
+            get("uninstall/{pkgName}", ExtensionController.uninstall)
 
-            get("icon/{apkName}", ExtensionController::icon)
+            get("icon/{apkName}", ExtensionController.icon)
         }
 
         path("source") {
-            get("list", SourceController::list)
+            get("list", SourceController.list)
-            get("{sourceId}", SourceController::retrieve)
+            get("{sourceId}", SourceController.retrieve)
 
-            get("{sourceId}/popular/{pageNum}", SourceController::popular)
+            get("{sourceId}/popular/{pageNum}", SourceController.popular)
-            get("{sourceId}/latest/{pageNum}", SourceController::latest)
+            get("{sourceId}/latest/{pageNum}", SourceController.latest)
 
-            get("{sourceId}/preferences", SourceController::getPreferences)
+            get("{sourceId}/preferences", SourceController.getPreferences)
-            post("{sourceId}/preferences", SourceController::setPreference)
+            post("{sourceId}/preferences", SourceController.setPreference)
 
-            get("{sourceId}/filters", SourceController::getFilters)
+            get("{sourceId}/filters", SourceController.getFilters)
-            post("{sourceId}/filters", SourceController::setFilter)
+            post("{sourceId}/filters", SourceController.setFilters)
 
-            get("{sourceId}/search", SourceController::searchSingle)
+            get("{sourceId}/search", SourceController.searchSingle)
-//            get("all/search", SourceController::searchGlobal) // TODO
+//            get("all/search", SourceController.searchGlobal) // TODO
         }
 
         path("manga") {
             get("{mangaId}", MangaController.retrieve)
-            get("{mangaId}/thumbnail", MangaController::thumbnail)
+            get("{mangaId}/thumbnail", MangaController.thumbnail)
 
-            get("{mangaId}/category", MangaController::categoryList)
+            get("{mangaId}/category", MangaController.categoryList)
-            get("{mangaId}/category/{categoryId}", MangaController::addToCategory)
+            get("{mangaId}/category/{categoryId}", MangaController.addToCategory)
-            delete("{mangaId}/category/{categoryId}", MangaController::removeFromCategory)
+            delete("{mangaId}/category/{categoryId}", MangaController.removeFromCategory)
 
-            get("{mangaId}/library", MangaController::addToLibrary)
+            get("{mangaId}/library", MangaController.addToLibrary)
-            delete("{mangaId}/library", MangaController::removeFromLibrary)
+            delete("{mangaId}/library", MangaController.removeFromLibrary)
 
-            patch("{mangaId}/meta", MangaController::meta)
+            patch("{mangaId}/meta", MangaController.meta)
 
-            get("{mangaId}/chapters", MangaController::chapterList)
+            get("{mangaId}/chapters", MangaController.chapterList)
-            get("{mangaId}/chapter/{chapterIndex}", MangaController::chapterRetrieve)
+            get("{mangaId}/chapter/{chapterIndex}", MangaController.chapterRetrieve)
-            patch("{mangaId}/chapter/{chapterIndex}", MangaController::chapterModify)
+            patch("{mangaId}/chapter/{chapterIndex}", MangaController.chapterModify)
-            delete("{mangaId}/chapter/{chapterIndex}", MangaController::chapterDelete)
+            delete("{mangaId}/chapter/{chapterIndex}", MangaController.chapterDelete)
 
-            patch("{mangaId}/chapter/{chapterIndex}/meta", MangaController::chapterMeta)
+            patch("{mangaId}/chapter/{chapterIndex}/meta", MangaController.chapterMeta)
 
-            get("{mangaId}/chapter/{chapterIndex}/page/{index}", MangaController::pageRetrieve)
+            get("{mangaId}/chapter/{chapterIndex}/page/{index}", MangaController.pageRetrieve)
         }
 
         path("category") {
-            get("", CategoryController::categoryList)
+            get("", CategoryController.categoryList)
-            post("", CategoryController::categoryCreate)
+            post("", CategoryController.categoryCreate)
 
             // The order here is important {categoryId} needs to be applied last
             // or throws a NumberFormatException
-            patch("reorder", CategoryController::categoryReorder)
+            patch("reorder", CategoryController.categoryReorder)
 
-            get("{categoryId}", CategoryController::categoryMangas)
+            get("{categoryId}", CategoryController.categoryMangas)
-            patch("{categoryId}", CategoryController::categoryModify)
+            patch("{categoryId}", CategoryController.categoryModify)
-            delete("{categoryId}", CategoryController::categoryDelete)
+            delete("{categoryId}", CategoryController.categoryDelete)
         }
 
         path("backup") {
-            post("import", BackupController::protobufImport)
+            post("import", BackupController.protobufImport)
-            post("import/file", BackupController::protobufImportFile)
+            post("import/file", BackupController.protobufImportFile)
 
-            post("validate", BackupController::protobufValidate)
+            post("validate", BackupController.protobufValidate)
-            post("validate/file", BackupController::protobufValidateFile)
+            post("validate/file", BackupController.protobufValidateFile)
 
-            get("export", BackupController::protobufExport)
+            get("export", BackupController.protobufExport)
-            get("export/file", BackupController::protobufExportFile)
+            get("export/file", BackupController.protobufExportFile)
         }
 
         path("downloads") {
             ws("", DownloadController::downloadsWS)
 
-            get("start", DownloadController::start)
+            get("start", DownloadController.start)
-            get("stop", DownloadController::stop)
+            get("stop", DownloadController.stop)
-            get("clear", DownloadController::stop)
+            get("clear", DownloadController.stop)
         }
 
         path("download") {
-            get("{mangaId}/chapter/{chapterIndex}", DownloadController::queueChapter)
+            get("{mangaId}/chapter/{chapterIndex}", DownloadController.queueChapter)
-            delete("{mangaId}/chapter/{chapterIndex}", DownloadController::unqueueChapter)
+            delete("{mangaId}/chapter/{chapterIndex}", DownloadController.unqueueChapter)
         }
 
         path("update") {
-            get("recentChapters/{pageNum}", UpdateController::recentChapters)
+            get("recentChapters/{pageNum}", UpdateController.recentChapters)
-            post("fetch", UpdateController::categoryUpdate)
+            post("fetch", UpdateController.categoryUpdate)
             post("reset", UpdateController.reset)
-            get("summary", UpdateController::updateSummary)
+            get("summary", UpdateController.updateSummary)
             ws("", UpdateController::categoryUpdateWS)
         }
     }

server/src/main/kotlin/suwayomi/tachidesk/manga/controller/BackupController.kt

@@ -1,11 +1,14 @@
 package suwayomi.tachidesk.manga.controller
 
-import io.javalin.http.Context
+import io.javalin.http.HttpCode
+import suwayomi.tachidesk.manga.impl.backup.AbstractBackupValidator
 import suwayomi.tachidesk.manga.impl.backup.BackupFlags
 import suwayomi.tachidesk.manga.impl.backup.proto.ProtoBackupExport
 import suwayomi.tachidesk.manga.impl.backup.proto.ProtoBackupImport
 import suwayomi.tachidesk.manga.impl.backup.proto.ProtoBackupValidator
 import suwayomi.tachidesk.server.JavalinSetup.future
+import suwayomi.tachidesk.server.util.handler
+import suwayomi.tachidesk.server.util.withOperation
 import java.text.SimpleDateFormat
 import java.util.Date
 
@@ -19,78 +22,155 @@ import java.util.Date
 object BackupController {
 
     /** expects a Tachiyomi protobuf backup in the body */
-    fun protobufImport(ctx: Context) {
+    val protobufImport = handler(
-        ctx.future(
+        documentWith = {
-            future {
+            withOperation {
-                ProtoBackupImport.performRestore(ctx.bodyAsInputStream())
+                summary("Restore a backup")
+                description("Expects a Tachiyomi protobuf backup in the body")
             }
-        )
+        },
-    }
+        behaviorOf = { ctx ->
+            ctx.future(
+                future {
+                    ProtoBackupImport.performRestore(ctx.bodyAsInputStream())
+                }
+            )
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+        }
+    )
 
     /** expects a Tachiyomi protobuf backup as a file upload, the file must be named "backup.proto.gz" */
-    fun protobufImportFile(ctx: Context) {
+    val protobufImportFile = handler(
-        // TODO: rewrite this with ctx.uploadedFiles(), don't call the multipart field "backup.proto.gz"
+        documentWith = {
-        ctx.future(
+            withOperation {
-            future {
+                summary("Restore a backup file")
-                ProtoBackupImport.performRestore(ctx.uploadedFile("backup.proto.gz")!!.content)
+                description("Expects a Tachiyomi protobuf backup as a file upload, the file must be named \"backup.proto.gz\"")
             }
-        )
+            uploadedFile("backup.proto.gz") {
-    }
+                it.description("Protobuf backup")
+                it.required(true)
+            }
+        },
+        behaviorOf = { ctx ->
+            // TODO: rewrite this with ctx.uploadedFiles(), don't call the multipart field "backup.proto.gz"
+            ctx.future(
+                future {
+                    ProtoBackupImport.performRestore(ctx.uploadedFile("backup.proto.gz")!!.content)
+                }
+            )
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+            httpCode(HttpCode.NOT_FOUND)
+        }
+    )
 
     /** returns a Tachiyomi protobuf backup created from the current database as a body */
-    fun protobufExport(ctx: Context) {
+    val protobufExport = handler(
-        ctx.contentType("application/octet-stream")
+        documentWith = {
-        ctx.future(
+            withOperation {
-            future {
+                summary("Create a backup")
-                ProtoBackupExport.createBackup(
+                description("Returns a Tachiyomi protobuf backup created from the current database as a body")
-                    BackupFlags(
-                        includeManga = true,
-                        includeCategories = true,
-                        includeChapters = true,
-                        includeTracking = true,
-                        includeHistory = true,
-                    )
-                )
             }
-        )
+        },
-    }
+        behaviorOf = { ctx ->
+            ctx.contentType("application/octet-stream")
+            ctx.future(
+                future {
+                    ProtoBackupExport.createBackup(
+                        BackupFlags(
+                            includeManga = true,
+                            includeCategories = true,
+                            includeChapters = true,
+                            includeTracking = true,
+                            includeHistory = true,
+                        )
+                    )
+                }
+            )
+        },
+        withResults = {
+            mime(HttpCode.OK, "application/octet-stream")
+        }
+    )
 
     /** returns a Tachiyomi protobuf backup created from the current database as a file */
-    fun protobufExportFile(ctx: Context) {
+    val protobufExportFile = handler(
-        ctx.contentType("application/octet-stream")
+        documentWith = {
-        val currentDate = SimpleDateFormat("yyyy-MM-dd_HH-mm").format(Date())
+            withOperation {
-
+                summary("Create a backup file")
-        ctx.header("Content-Disposition", """attachment; filename="tachidesk_$currentDate.proto.gz"""")
+                description("Returns a Tachiyomi protobuf backup created from the current database as a file")
-        ctx.future(
-            future {
-                ProtoBackupExport.createBackup(
-                    BackupFlags(
-                        includeManga = true,
-                        includeCategories = true,
-                        includeChapters = true,
-                        includeTracking = true,
-                        includeHistory = true,
-                    )
-                )
             }
-        )
+        },
-    }
+        behaviorOf = { ctx ->
+            ctx.contentType("application/octet-stream")
+            val currentDate = SimpleDateFormat("yyyy-MM-dd_HH-mm").format(Date())
+
+            ctx.header("Content-Disposition", """attachment; filename="tachidesk_$currentDate.proto.gz"""")
+            ctx.future(
+                future {
+                    ProtoBackupExport.createBackup(
+                        BackupFlags(
+                            includeManga = true,
+                            includeCategories = true,
+                            includeChapters = true,
+                            includeTracking = true,
+                            includeHistory = true,
+                        )
+                    )
+                }
+            )
+        },
+        withResults = {
+            mime(HttpCode.OK, "application/octet-stream")
+        }
+    )
 
     /** Reports missing sources and trackers, expects a Tachiyomi protobuf backup in the body */
-    fun protobufValidate(ctx: Context) {
+    val protobufValidate = handler(
-        ctx.future(
+        documentWith = {
-            future {
+            withOperation {
-                ProtoBackupValidator.validate(ctx.bodyAsInputStream())
+                summary("Validate a backup")
+                description("Reports missing sources and trackers, expects a Tachiyomi protobuf backup in the body")
             }
-        )
+            body<ByteArray>("") {
-    }
+            }
+        },
+        behaviorOf = { ctx ->
+            ctx.future(
+                future {
+                    ProtoBackupValidator.validate(ctx.bodyAsInputStream())
+                }
+            )
+        },
+        withResults = {
+            json<AbstractBackupValidator.ValidationResult>(HttpCode.OK)
+        }
+    )
 
     /** Reports missing sources and trackers, expects a Tachiyomi protobuf backup as a file upload, the file must be named "backup.proto.gz" */
-    fun protobufValidateFile(ctx: Context) {
+    val protobufValidateFile = handler(
-        ctx.future(
+        documentWith = {
-            future {
+            withOperation {
-                ProtoBackupValidator.validate(ctx.uploadedFile("backup.proto.gz")!!.content)
+                summary("Validate a backup file")
+                description("Reports missing sources and trackers, expects a Tachiyomi protobuf backup as a file upload, the file must be named \"backup.proto.gz\"")
             }
-        )
+            uploadedFile("backup.proto.gz") {
-    }
+                it.description("Protobuf backup")
+                it.required(true)
+            }
+        },
+        behaviorOf = { ctx ->
+            ctx.future(
+                future {
+                    ProtoBackupValidator.validate(ctx.uploadedFile("backup.proto.gz")!!.content)
+                }
+            )
+        },
+        withResults = {
+            json<AbstractBackupValidator.ValidationResult>(HttpCode.OK)
+        }
+    )
 }

server/src/main/kotlin/suwayomi/tachidesk/manga/controller/CategoryController.kt

@@ -7,50 +7,126 @@ package suwayomi.tachidesk.manga.controller
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-import io.javalin.http.Context
+import io.javalin.http.HttpCode
 import suwayomi.tachidesk.manga.impl.Category
 import suwayomi.tachidesk.manga.impl.CategoryManga
+import suwayomi.tachidesk.manga.model.dataclass.CategoryDataClass
+import suwayomi.tachidesk.manga.model.dataclass.MangaDataClass
+import suwayomi.tachidesk.server.util.formParam
+import suwayomi.tachidesk.server.util.handler
+import suwayomi.tachidesk.server.util.pathParam
+import suwayomi.tachidesk.server.util.withOperation
 
 object CategoryController {
     /** category list */
-    fun categoryList(ctx: Context) {
+    val categoryList = handler(
-        ctx.json(Category.getCategoryList())
+        documentWith = {
-    }
+            withOperation {
+                summary("Category list")
+                description("get a list of categories")
+            }
+        },
+        behaviorOf = { ctx ->
+            ctx.json(Category.getCategoryList())
+        },
+        withResults = {
+            json<List<CategoryDataClass>>(HttpCode.OK)
+        }
+    )
 
     /** category create */
-    fun categoryCreate(ctx: Context) {
+    val categoryCreate = handler(
-        val name = ctx.formParam("name")!!
+        formParam<String>("name"),
-        Category.createCategory(name)
+        documentWith = {
-        ctx.status(200)
+            withOperation {
-    }
+                summary("Category create")
+                description("Create a category")
+            }
+        },
+        behaviorOf = { ctx, name ->
+            if (Category.createCategory(name) != -1) {
+                ctx.status(200)
+            } else {
+                ctx.status(HttpCode.BAD_REQUEST)
+            }
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+            httpCode(HttpCode.BAD_REQUEST)
+        }
+    )
 
     /** category modification */
-    fun categoryModify(ctx: Context) {
+    val categoryModify = handler(
-        val categoryId = ctx.pathParam("categoryId").toInt()
+        pathParam<Int>("categoryId"),
-        val name = ctx.formParam("name")
+        formParam<String?>("name"),
-        val isDefault = ctx.formParam("default")?.toBoolean()
+        formParam<Boolean?>("default"),
-        Category.updateCategory(categoryId, name, isDefault)
+        documentWith = {
-        ctx.status(200)
+            withOperation {
-    }
+                summary("Category modify")
+                description("Modify a category")
+            }
+        },
+        behaviorOf = { ctx, categoryId, name, isDefault ->
+            Category.updateCategory(categoryId, name, isDefault)
+            ctx.status(200)
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+        }
+    )
 
     /** category delete */
-    fun categoryDelete(ctx: Context) {
+    val categoryDelete = handler(
-        val categoryId = ctx.pathParam("categoryId").toInt()
+        pathParam<Int>("categoryId"),
-        Category.removeCategory(categoryId)
+        documentWith = {
-        ctx.status(200)
+            withOperation {
-    }
+                summary("Category delete")
+                description("Delete a category")
+            }
+        },
+        behaviorOf = { ctx, categoryId ->
+            Category.removeCategory(categoryId)
+            ctx.status(200)
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+        }
+    )
 
     /** returns the manga list associated with a category */
-    fun categoryMangas(ctx: Context) {
+    val categoryMangas = handler(
-        val categoryId = ctx.pathParam("categoryId").toInt()
+        pathParam<Int>("categoryId"),
-        ctx.json(CategoryManga.getCategoryMangaList(categoryId))
+        documentWith = {
-    }
+            withOperation {
+                summary("Category manga")
+                description("Returns the manga list associated with a category")
+            }
+        },
+        behaviorOf = { ctx, categoryId ->
+            ctx.json(CategoryManga.getCategoryMangaList(categoryId))
+        },
+        withResults = {
+            json<List<MangaDataClass>>(HttpCode.OK)
+        }
+    )
 
     /** category re-ordering */
-    fun categoryReorder(ctx: Context) {
+    val categoryReorder = handler(
-        val from = ctx.formParam("from")!!.toInt()
+        formParam<Int>("from"),
-        val to = ctx.formParam("to")!!.toInt()
+        formParam<Int>("to"),
-        Category.reorderCategory(from, to)
+        documentWith = {
-        ctx.status(200)
+            withOperation {
-    }
+                summary("Category re-ordering")
+                description("Re-order a category")
+            }
+        },
+        behaviorOf = { ctx, from, to ->
+            Category.reorderCategory(from, to)
+            ctx.status(200)
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+        }
+    )
 }

server/src/main/kotlin/suwayomi/tachidesk/manga/controller/DownloadController.kt

@@ -7,10 +7,13 @@ package suwayomi.tachidesk.manga.controller
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-import io.javalin.http.Context
+import io.javalin.http.HttpCode
 import io.javalin.websocket.WsConfig
 import suwayomi.tachidesk.manga.impl.download.DownloadManager
 import suwayomi.tachidesk.server.JavalinSetup.future
+import suwayomi.tachidesk.server.util.handler
+import suwayomi.tachidesk.server.util.pathParam
+import suwayomi.tachidesk.server.util.withOperation
 
 object DownloadController {
     /** Download queue stats */
@@ -28,45 +31,99 @@ object DownloadController {
     }
 
     /** Start the downloader */
-    fun start(ctx: Context) {
+    val start = handler(
-        DownloadManager.start()
+        documentWith = {
+            withOperation {
+                summary("Downloader start")
+                description("Start the downloader")
+            }
+        },
+        behaviorOf = { ctx ->
+            DownloadManager.start()
 
-        ctx.status(200)
+            ctx.status(200)
-    }
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+        }
+    )
 
     /** Stop the downloader */
-    fun stop(ctx: Context) {
+    val stop = handler(
-        DownloadManager.stop()
+        documentWith = {
+            withOperation {
+                summary("Downloader stop")
+                description("Stop the downloader")
+            }
+        },
+        behaviorOf = { ctx ->
+            DownloadManager.stop()
 
-        ctx.status(200)
+            ctx.status(200)
-    }
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+        }
+    )
 
     /** clear download queue */
-    fun clear(ctx: Context) {
+    val clear = handler(
-        DownloadManager.clear()
+        documentWith = {
+            withOperation {
+                summary("Downloader clear")
+                description("Clear download queue")
+            }
+        },
+        behaviorOf = { ctx ->
+            DownloadManager.clear()
 
-        ctx.status(200)
+            ctx.status(200)
-    }
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+        }
+    )
 
     /** Queue chapter for download */
-    fun queueChapter(ctx: Context) {
+    val queueChapter = handler(
-        val chapterIndex = ctx.pathParam("chapterIndex").toInt()
+        pathParam<Int>("chapterIndex"),
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("mangaId"),
-
+        documentWith = {
-        ctx.future(
+            withOperation {
-            future {
+                summary("Downloader add chapter")
-                DownloadManager.enqueue(chapterIndex, mangaId)
+                description("Queue chapter for download")
             }
-        )
+        },
-    }
+        behaviorOf = { ctx, chapterIndex, mangaId ->
+            ctx.future(
+                future {
+                    DownloadManager.enqueue(chapterIndex, mangaId)
+                }
+            )
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+            httpCode(HttpCode.NOT_FOUND)
+        }
+    )
 
     /** delete chapter from download queue */
-    fun unqueueChapter(ctx: Context) {
+    val unqueueChapter = handler(
-        val chapterIndex = ctx.pathParam("chapterIndex").toInt()
+        pathParam<Int>("chapterIndex"),
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("mangaId"),
+        documentWith = {
+            withOperation {
+                summary("Downloader remove chapter")
+                description("Delete chapter from download queue")
+            }
+        },
+        behaviorOf = { ctx, chapterIndex, mangaId ->
+            DownloadManager.unqueue(chapterIndex, mangaId)
 
-        DownloadManager.unqueue(chapterIndex, mangaId)
+            ctx.status(200)
-
+        },
-        ctx.status(200)
+        withResults = {
-    }
+            httpCode(HttpCode.OK)
+        }
+    )
 }

server/src/main/kotlin/suwayomi/tachidesk/manga/controller/ExtensionController.kt

@@ -7,78 +7,159 @@ package suwayomi.tachidesk.manga.controller
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-import io.javalin.http.Context
+import io.javalin.http.HttpCode
 import mu.KotlinLogging
 import suwayomi.tachidesk.manga.impl.extension.Extension
 import suwayomi.tachidesk.manga.impl.extension.ExtensionsList
+import suwayomi.tachidesk.manga.model.dataclass.ExtensionDataClass
 import suwayomi.tachidesk.server.JavalinSetup.future
+import suwayomi.tachidesk.server.util.handler
+import suwayomi.tachidesk.server.util.pathParam
+import suwayomi.tachidesk.server.util.queryParam
+import suwayomi.tachidesk.server.util.withOperation
 
 object ExtensionController {
     private val logger = KotlinLogging.logger {}
 
     /** list all extensions */
-    fun list(ctx: Context) {
+    val list = handler(
-        ctx.future(
+        documentWith = {
-            future {
+            withOperation {
-                ExtensionsList.getExtensionList()
+                summary("Extension list")
+                description("List all extensions")
             }
-        )
+        },
-    }
+        behaviorOf = { ctx ->
+            ctx.future(
+                future {
+                    ExtensionsList.getExtensionList()
+                }
+            )
+        },
+        withResults = {
+            json<List<ExtensionDataClass>>(HttpCode.OK)
+        }
+    )
 
     /** install extension identified with "pkgName" */
-    fun install(ctx: Context) {
+    val install = handler(
-        val pkgName = ctx.pathParam("pkgName")
+        pathParam<String>("pkgName"),
-
+        documentWith = {
-        ctx.future(
+            withOperation {
-            future {
+                summary("Extension install")
-                Extension.installExtension(pkgName)
+                description("install extension identified with \"pkgName\"")
             }
-        )
+        },
-    }
+        behaviorOf = { ctx, pkgName ->
+            ctx.future(
+                future {
+                    Extension.installExtension(pkgName)
+                }
+            )
+        },
+        withResults = {
+            httpCode(HttpCode.CREATED)
+            httpCode(HttpCode.FOUND)
+            httpCode(HttpCode.INTERNAL_SERVER_ERROR)
+        }
+    )
 
     /** install the uploaded apk file */
-    fun installFile(ctx: Context) {
+    val installFile = handler(
-
+        documentWith = {
-        val uploadedFile = ctx.uploadedFile("file")!!
+            withOperation {
-        logger.debug { "Uploaded extension file name: " + uploadedFile.filename }
+                summary("Extension install apk")
-
+                description("Install the uploaded apk file")
-        ctx.future(
-            future {
-                Extension.installExternalExtension(uploadedFile.content, uploadedFile.filename)
             }
-        )
+            uploadedFile("file") {
-    }
+                it.description("Extension apk")
+                it.required(true)
+            }
+        },
+        behaviorOf = { ctx ->
+            val uploadedFile = ctx.uploadedFile("file")!!
+            logger.debug { "Uploaded extension file name: " + uploadedFile.filename }
+
+            ctx.future(
+                future {
+                    Extension.installExternalExtension(uploadedFile.content, uploadedFile.filename)
+                }
+            )
+        },
+        withResults = {
+            httpCode(HttpCode.CREATED)
+            httpCode(HttpCode.FOUND)
+            httpCode(HttpCode.INTERNAL_SERVER_ERROR)
+        }
+    )
 
     /** update extension identified with "pkgName" */
-    fun update(ctx: Context) {
+    val update = handler(
-        val pkgName = ctx.pathParam("pkgName")
+        pathParam<String>("pkgName"),
-
+        documentWith = {
-        ctx.future(
+            withOperation {
-            future {
+                summary("Extension update")
-                Extension.updateExtension(pkgName)
+                description("Update extension identified with \"pkgName\"")
             }
-        )
+        },
-    }
+        behaviorOf = { ctx, pkgName ->
+            ctx.future(
+                future {
+                    Extension.updateExtension(pkgName)
+                }
+            )
+        },
+        withResults = {
+            httpCode(HttpCode.CREATED)
+            httpCode(HttpCode.FOUND)
+            httpCode(HttpCode.NOT_FOUND)
+            httpCode(HttpCode.INTERNAL_SERVER_ERROR)
+        }
+    )
 
     /** uninstall extension identified with "pkgName" */
-    fun uninstall(ctx: Context) {
+    val uninstall = handler(
-        val pkgName = ctx.pathParam("pkgName")
+        pathParam<String>("pkgName"),
-
+        documentWith = {
-        Extension.uninstallExtension(pkgName)
+            withOperation {
-        ctx.status(200)
+                summary("Extension uninstall")
-    }
+                description("Uninstall extension identified with \"pkgName\"")
+            }
+        },
+        behaviorOf = { ctx, pkgName ->
+            Extension.uninstallExtension(pkgName)
+            ctx.status(200)
+        },
+        withResults = {
+            httpCode(HttpCode.CREATED)
+            httpCode(HttpCode.FOUND)
+            httpCode(HttpCode.NOT_FOUND)
+            httpCode(HttpCode.INTERNAL_SERVER_ERROR)
+        }
+    )
 
     /** icon for extension named `apkName` */
-    fun icon(ctx: Context) {
+    val icon = handler(
-        val apkName = ctx.pathParam("apkName")
+        pathParam<String>("apkName"),
-        val useCache = ctx.queryParam("useCache")?.toBoolean() ?: true
+        queryParam("useCache", true),
-
+        documentWith = {
-        ctx.future(
+            withOperation {
-            future { Extension.getExtensionIcon(apkName, useCache) }
+                summary("Extension icon")
-                .thenApply {
+                description("Icon for extension named `apkName`")
-                    ctx.header("content-type", it.second)
+            }
-                    it.first
+        },
-                }
+        behaviorOf = { ctx, apkName, useCache ->
-        )
+            ctx.future(
-    }
+                future { Extension.getExtensionIcon(apkName, useCache) }
+                    .thenApply {
+                        ctx.header("content-type", it.second)
+                        it.first
+                    }
+            )
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+            httpCode(HttpCode.NOT_FOUND)
+        }
+    )
 }

server/src/main/kotlin/suwayomi/tachidesk/manga/controller/MangaController.kt

@@ -7,7 +7,6 @@ package suwayomi.tachidesk.manga.controller
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-import io.javalin.http.Context
 import io.javalin.http.HttpCode
 import suwayomi.tachidesk.manga.impl.CategoryManga
 import suwayomi.tachidesk.manga.impl.Chapter
@@ -15,8 +14,11 @@ import suwayomi.tachidesk.manga.impl.Library
 import suwayomi.tachidesk.manga.impl.Manga
 import suwayomi.tachidesk.manga.impl.Page
 import suwayomi.tachidesk.manga.impl.chapter.getChapterDownloadReady
+import suwayomi.tachidesk.manga.model.dataclass.CategoryDataClass
+import suwayomi.tachidesk.manga.model.dataclass.ChapterDataClass
 import suwayomi.tachidesk.manga.model.dataclass.MangaDataClass
 import suwayomi.tachidesk.server.JavalinSetup.future
+import suwayomi.tachidesk.server.util.formParam
 import suwayomi.tachidesk.server.util.handler
 import suwayomi.tachidesk.server.util.pathParam
 import suwayomi.tachidesk.server.util.queryParam
@@ -30,7 +32,7 @@ object MangaController {
         documentWith = {
             withOperation {
                 summary("Get a manga")
-                description("Get a manga from the database using a specific id")
+                description("Get a manga from the database using a specific id.")
             }
         },
         behaviorOf = { ctx, mangaId, onlineFetch ->
@@ -47,140 +49,278 @@ object MangaController {
     )
 
     /** manga thumbnail */
-    fun thumbnail(ctx: Context) {
+    val thumbnail = handler(
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("mangaId"),
-        val useCache = ctx.queryParam("useCache")?.toBoolean() ?: true
+        queryParam("useCache", true),
-
+        documentWith = {
-        ctx.future(
+            withOperation {
-            future { Manga.getMangaThumbnail(mangaId, useCache) }
+                summary("Get a manga thumbnail")
-                .thenApply {
+                description("Get a manga thumbnail from the source or the cache.")
-                    ctx.header("content-type", it.second)
+            }
-                    val httpCacheSeconds = 60 * 60 * 24
+        },
-                    ctx.header("cache-control", "max-age=$httpCacheSeconds")
+        behaviorOf = { ctx, mangaId, useCache ->
-                    it.first
+            ctx.future(
-                }
+                future { Manga.getMangaThumbnail(mangaId, useCache) }
-        )
+                    .thenApply {
-    }
+                        ctx.header("content-type", it.second)
+                        val httpCacheSeconds = 60 * 60 * 24
+                        ctx.header("cache-control", "max-age=$httpCacheSeconds")
+                        it.first
+                    }
+            )
+        },
+        withResults = {
+            mime(HttpCode.OK, "image/*")
+            httpCode(HttpCode.NOT_FOUND)
+        }
+    )
 
     /** adds the manga to library */
-    fun addToLibrary(ctx: Context) {
+    val addToLibrary = handler(
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("mangaId"),
-
+        documentWith = {
-        ctx.future(
+            withOperation {
-            future { Library.addMangaToLibrary(mangaId) }
+                summary("Add manga to library")
-        )
+                description("Use a manga id to add the manga to your library.\nWill do nothing if manga is already in your library.")
-    }
+            }
+        },
+        behaviorOf = { ctx, mangaId ->
+            ctx.future(
+                future { Library.addMangaToLibrary(mangaId) }
+            )
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+            httpCode(HttpCode.NOT_FOUND)
+        }
+    )
 
     /** removes the manga from the library */
-    fun removeFromLibrary(ctx: Context) {
+    val removeFromLibrary = handler(
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("mangaId"),
-
+        documentWith = {
-        ctx.future(
+            withOperation {
-            future { Library.removeMangaFromLibrary(mangaId) }
+                summary("Remove manga to library")
-        )
+                description("Use a manga id to remove the manga to your library.\nWill do nothing if manga not in your library.")
-    }
+            }
+        },
+        behaviorOf = { ctx, mangaId ->
+            ctx.future(
+                future { Library.removeMangaFromLibrary(mangaId) }
+            )
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+            httpCode(HttpCode.NOT_FOUND)
+        }
+    )
 
     /** list manga's categories */
-    fun categoryList(ctx: Context) {
+    val categoryList = handler(
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("mangaId"),
-        ctx.json(CategoryManga.getMangaCategories(mangaId))
+        documentWith = {
-    }
+            withOperation {
+                summary("Get a manga's categories")
+                description("Get the list of categories for this manga")
+            }
+        },
+        behaviorOf = { ctx, mangaId ->
+            ctx.json(CategoryManga.getMangaCategories(mangaId))
+        },
+        withResults = {
+            json<List<CategoryDataClass>>(HttpCode.OK)
+        }
+    )
 
     /** adds the manga to category */
-    fun addToCategory(ctx: Context) {
+    val addToCategory = handler(
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("mangaId"),
-        val categoryId = ctx.pathParam("categoryId").toInt()
+        pathParam<Int>("categoryId"),
-        CategoryManga.addMangaToCategory(mangaId, categoryId)
+        documentWith = {
-        ctx.status(200)
+            withOperation {
-    }
+                summary("Add manga to category")
+                description("Add a manga to a category using their ids.")
+            }
+        },
+        behaviorOf = { ctx, mangaId, categoryId ->
+            CategoryManga.addMangaToCategory(mangaId, categoryId)
+            ctx.status(200)
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+        }
+    )
 
     /** removes the manga from the category */
-    fun removeFromCategory(ctx: Context) {
+    val removeFromCategory = handler(
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("mangaId"),
-        val categoryId = ctx.pathParam("categoryId").toInt()
+        pathParam<Int>("categoryId"),
-        CategoryManga.removeMangaFromCategory(mangaId, categoryId)
+        documentWith = {
-        ctx.status(200)
+            withOperation {
-    }
+                summary("Remove manga from category")
+                description("Remove a manga from a category using their ids.")
+            }
+        },
+        behaviorOf = { ctx, mangaId, categoryId ->
+            CategoryManga.removeMangaFromCategory(mangaId, categoryId)
+            ctx.status(200)
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+        }
+    )
 
     /** used to modify a manga's meta parameters */
-    fun meta(ctx: Context) {
+    val meta = handler(
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("mangaId"),
-
+        formParam<String>("key"),
-        val key = ctx.formParam("key")!!
+        formParam<String>("value"),
-        val value = ctx.formParam("value")!!
+        documentWith = {
-
+            withOperation {
-        Manga.modifyMangaMeta(mangaId, key, value)
+                summary("Add data to manga")
-
+                description("A simple Key-Value storage in the manga object, you can set values for whatever you want inside it.")
-        ctx.status(200)
+            }
-    }
+        },
+        behaviorOf = { ctx, mangaId, key, value ->
+            Manga.modifyMangaMeta(mangaId, key, value)
+            ctx.status(200)
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+            httpCode(HttpCode.NOT_FOUND)
+        }
+    )
 
     /** get chapter list when showing a manga */
-    fun chapterList(ctx: Context) {
+    val chapterList = handler(
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("mangaId"),
-
+        queryParam("onlineFetch", false),
-        val onlineFetch = ctx.queryParam("onlineFetch")?.toBoolean() ?: false
+        documentWith = {
-
+            withOperation {
-        ctx.future(future { Chapter.getChapterList(mangaId, onlineFetch) })
+                summary("Get manga chapter list")
-    }
+                description("Get the manga chapter list from the database or online. If there is no chapters in the database it fetches the chapters online. Use onlineFetch to update chapter list.")
+            }
+        },
+        behaviorOf = { ctx, mangaId, onlineFetch ->
+            ctx.future(future { Chapter.getChapterList(mangaId, onlineFetch) })
+        },
+        withResults = {
+            json<List<ChapterDataClass>>(HttpCode.OK)
+            httpCode(HttpCode.NOT_FOUND)
+        }
+    )
 
     /** used to display a chapter, get a chapter in order to show its pages */
-    fun chapterRetrieve(ctx: Context) {
+    val chapterRetrieve = handler(
-        val chapterIndex = ctx.pathParam("chapterIndex").toInt()
+        pathParam<Int>("mangaId"),
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("chapterIndex"),
-        ctx.future(future { getChapterDownloadReady(chapterIndex, mangaId) })
+        documentWith = {
-    }
+            withOperation {
+                summary("Get a chapter")
+                description("Get the chapter from the manga id and chapter index. It will also retrieve the pages for this chapter.")
+            }
+        },
+        behaviorOf = { ctx, mangaId, chapterIndex ->
+            ctx.future(future { getChapterDownloadReady(chapterIndex, mangaId) })
+        },
+        withResults = {
+            json<ChapterDataClass>(HttpCode.OK)
+            httpCode(HttpCode.NOT_FOUND)
+        }
+    )
 
     /** used to modify a chapter's parameters */
-    fun chapterModify(ctx: Context) {
+    val chapterModify = handler(
-        val chapterIndex = ctx.pathParam("chapterIndex").toInt()
+        pathParam<Int>("mangaId"),
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("chapterIndex"),
+        formParam<Boolean?>("read"),
+        formParam<Boolean?>("bookmarked"),
+        formParam<Boolean?>("markPrevRead"),
+        formParam<Int?>("lastPageRead"),
+        documentWith = {
+            withOperation {
+                summary("Modify a chapter")
+                description("Update user info for a given chapter, such as read status, bookmarked, and more.")
+            }
+        },
+        behaviorOf = { ctx, mangaId, chapterIndex, read, bookmarked, markPrevRead, lastPageRead ->
+            Chapter.modifyChapter(mangaId, chapterIndex, read, bookmarked, markPrevRead, lastPageRead)
 
-        val read = ctx.formParam("read")?.toBoolean()
+            ctx.status(200)
-        val bookmarked = ctx.formParam("bookmarked")?.toBoolean()
+        },
-        val markPrevRead = ctx.formParam("markPrevRead")?.toBoolean()
+        withResults = {
-        val lastPageRead = ctx.formParam("lastPageRead")?.toInt()
+            httpCode(HttpCode.OK)
-
+        }
-        Chapter.modifyChapter(mangaId, chapterIndex, read, bookmarked, markPrevRead, lastPageRead)
+    )
-
-        ctx.status(200)
-    }
 
     /** delete a downloaded chapter */
-    fun chapterDelete(ctx: Context) {
+    val chapterDelete = handler(
-        val chapterIndex = ctx.pathParam("chapterIndex").toInt()
+        pathParam<Int>("mangaId"),
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("chapterIndex"),
+        documentWith = {
+            withOperation {
+                summary("Delete a chapter download")
+                description("Delete the downloaded chapter and its files.")
+            }
+        },
+        behaviorOf = { ctx, mangaId, chapterIndex ->
+            Chapter.deleteChapter(mangaId, chapterIndex)
 
-        Chapter.deleteChapter(mangaId, chapterIndex)
+            ctx.status(200)
-
+        },
-        ctx.status(200)
+        withResults = {
-    }
+            httpCode(HttpCode.OK)
+            httpCode(HttpCode.NOT_FOUND)
+        }
+    )
 
     /** used to modify a chapter's meta parameters */
-    fun chapterMeta(ctx: Context) {
+    val chapterMeta = handler(
-        val chapterIndex = ctx.pathParam("chapterIndex").toInt()
+        pathParam<Int>("mangaId"),
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("chapterIndex"),
+        formParam<String>("key"),
+        formParam<String>("value"),
+        documentWith = {
+            withOperation {
+                summary("Add data to chapter")
+                description("A simple Key-Value storage in the chapter object, you can set values for whatever you want inside it.")
+            }
+        },
+        behaviorOf = { ctx, mangaId, chapterIndex, key, value ->
+            Chapter.modifyChapterMeta(mangaId, chapterIndex, key, value)
 
-        val key = ctx.formParam("key")!!
+            ctx.status(200)
-        val value = ctx.formParam("value")!!
+        },
-
+        withResults = {
-        Chapter.modifyChapterMeta(mangaId, chapterIndex, key, value)
+            httpCode(HttpCode.OK)
-
+            httpCode(HttpCode.NOT_FOUND)
-        ctx.status(200)
+        }
-    }
+    )
 
     /** get page at index "index" */
-    fun pageRetrieve(ctx: Context) {
+    val pageRetrieve = handler(
-        val mangaId = ctx.pathParam("mangaId").toInt()
+        pathParam<Int>("mangaId"),
-        val chapterIndex = ctx.pathParam("chapterIndex").toInt()
+        pathParam<Int>("chapterIndex"),
-        val index = ctx.pathParam("index").toInt()
+        pathParam<Int>("index"),
-        val useCache = ctx.queryParam("useCache")?.toBoolean() ?: true
+        queryParam("useCache", true),
-
+        documentWith = {
-        ctx.future(
+            withOperation {
-            future { Page.getPageImage(mangaId, chapterIndex, index, useCache) }
+                summary("Get a chapter page")
-                .thenApply {
+                description("Get a chapter page for a given index. Cache use can be disabled so it only retrieves it directly from the source.")
-                    ctx.header("content-type", it.second)
+            }
-                    it.first
+        },
-                }
+        behaviorOf = { ctx, mangaId, chapterIndex, index, useCache ->
-        )
+            ctx.future(
-    }
+                future { Page.getPageImage(mangaId, chapterIndex, index, useCache) }
+                    .thenApply {
+                        ctx.header("content-type", it.second)
+                        it.first
+                    }
+            )
+        },
+        withResults = {
+            mime(HttpCode.OK, "image/*")
+            httpCode(HttpCode.NOT_FOUND)
+        }
+    )
 }

server/src/main/kotlin/suwayomi/tachidesk/manga/controller/SourceController.kt

@@ -7,87 +7,215 @@ package suwayomi.tachidesk.manga.controller
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-import io.javalin.http.Context
+import io.javalin.http.HttpCode
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.json.Json
+import org.kodein.di.DI
+import org.kodein.di.conf.global
+import org.kodein.di.instance
 import suwayomi.tachidesk.manga.impl.MangaList
 import suwayomi.tachidesk.manga.impl.Search
 import suwayomi.tachidesk.manga.impl.Search.FilterChange
 import suwayomi.tachidesk.manga.impl.Source
 import suwayomi.tachidesk.manga.impl.Source.SourcePreferenceChange
+import suwayomi.tachidesk.manga.model.dataclass.PagedMangaListDataClass
 import suwayomi.tachidesk.server.JavalinSetup.future
+import suwayomi.tachidesk.server.util.handler
+import suwayomi.tachidesk.server.util.pathParam
+import suwayomi.tachidesk.server.util.queryParam
+import suwayomi.tachidesk.server.util.withOperation
+import javax.sound.sampled.SourceDataLine
 
 object SourceController {
     /** list of sources */
-    fun list(ctx: Context) {
+    val list = handler(
-        ctx.json(Source.getSourceList())
+        documentWith = {
-    }
+            withOperation {
+                summary("Sources list")
+                description("List of sources")
+            }
+        },
+        behaviorOf = { ctx ->
+            ctx.json(Source.getSourceList())
+        },
+        withResults = {
+            json<List<SourceDataLine>>(HttpCode.OK)
+        }
+    )
 
     /** fetch source with id `sourceId` */
-    fun retrieve(ctx: Context) {
+    val retrieve = handler(
-        val sourceId = ctx.pathParam("sourceId").toLong()
+        pathParam<Long>("sourceId"),
-        ctx.json(Source.getSource(sourceId))
+        documentWith = {
-    }
+            withOperation {
+                summary("Source fetch")
+                description("Fetch source with id `sourceId`")
+            }
+        },
+        behaviorOf = { ctx, sourceId ->
+            ctx.json(Source.getSource(sourceId)!!)
+        },
+        withResults = {
+            json<SourceDataLine>(HttpCode.OK)
+            httpCode(HttpCode.NOT_FOUND)
+        }
+    )
 
     /** popular mangas from source with id `sourceId` */
-    fun popular(ctx: Context) {
+    val popular = handler(
-        val sourceId = ctx.pathParam("sourceId").toLong()
+        pathParam<Long>("sourceId"),
-        val pageNum = ctx.pathParam("pageNum").toInt()
+        pathParam<Int>("pageNum"),
-        ctx.future(
+        documentWith = {
-            future {
+            withOperation {
-                MangaList.getMangaList(sourceId, pageNum, popular = true)
+                summary("Source popular manga")
+                description("Popular mangas from source with id `sourceId`")
             }
-        )
+        },
-    }
+        behaviorOf = { ctx, sourceId, pageNum ->
+            ctx.future(
+                future {
+                    MangaList.getMangaList(sourceId, pageNum, popular = true)
+                }
+            )
+        },
+        withResults = {
+            json<PagedMangaListDataClass>(HttpCode.OK)
+        }
+    )
 
     /** latest mangas from source with id `sourceId` */
-    fun latest(ctx: Context) {
+    val latest = handler(
-        val sourceId = ctx.pathParam("sourceId").toLong()
+        pathParam<Long>("sourceId"),
-        val pageNum = ctx.pathParam("pageNum").toInt()
+        pathParam<Int>("pageNum"),
-        ctx.future(
+        documentWith = {
-            future {
+            withOperation {
-                MangaList.getMangaList(sourceId, pageNum, popular = false)
+                summary("Source latest manga")
+                description("Latest mangas from source with id `sourceId`")
             }
-        )
+        },
-    }
+        behaviorOf = { ctx, sourceId, pageNum ->
+            ctx.future(
+                future {
+                    MangaList.getMangaList(sourceId, pageNum, popular = false)
+                }
+            )
+        },
+        withResults = {
+            json<PagedMangaListDataClass>(HttpCode.OK)
+        }
+    )
 
     /** fetch preferences of source with id `sourceId` */
-    fun getPreferences(ctx: Context) {
+    val getPreferences = handler(
-        val sourceId = ctx.pathParam("sourceId").toLong()
+        pathParam<Long>("sourceId"),
-        ctx.json(Source.getSourcePreferences(sourceId))
+        documentWith = {
-    }
+            withOperation {
+                summary("Source preferences")
+                description("Fetch preferences of source with id `sourceId`")
+            }
+        },
+        behaviorOf = { ctx, sourceId ->
+            ctx.json(Source.getSourcePreferences(sourceId))
+        },
+        withResults = {
+            json<List<Source.PreferenceObject>>(HttpCode.OK)
+        }
+    )
 
     /** set one preference of source with id `sourceId` */
-    fun setPreference(ctx: Context) {
+    val setPreference = handler(
-        val sourceId = ctx.pathParam("sourceId").toLong()
+        pathParam<Long>("sourceId"),
-        val preferenceChange = ctx.bodyAsClass(SourcePreferenceChange::class.java)
+        documentWith = {
-        ctx.json(Source.setSourcePreference(sourceId, preferenceChange))
+            withOperation {
-    }
+                summary("Source preference set")
+                description("Set one preference of source with id `sourceId`")
+            }
+        },
+        behaviorOf = { ctx, sourceId ->
+            val preferenceChange = ctx.bodyAsClass(SourcePreferenceChange::class.java)
+            ctx.json(Source.setSourcePreference(sourceId, preferenceChange))
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+        }
+    )
 
     /** fetch filters of source with id `sourceId` */
-    fun getFilters(ctx: Context) {
+    val getFilters = handler(
-        val sourceId = ctx.pathParam("sourceId").toLong()
+        pathParam<Long>("sourceId"),
-        val reset = ctx.queryParam("reset")?.toBoolean() ?: false
+        queryParam("reset", false),
-        ctx.json(Search.getFilterList(sourceId, reset))
+        documentWith = {
-    }
+            withOperation {
+                summary("Source filters")
+                description("Fetch filters of source with id `sourceId`")
+            }
+        },
+        behaviorOf = { ctx, sourceId, reset ->
+            ctx.json(Search.getFilterList(sourceId, reset))
+        },
+        withResults = {
+            json<List<Search.FilterObject>>(HttpCode.OK)
+        }
+    )
 
-    /** set one filter of source with id `sourceId` */
+    private val json by DI.global.instance<Json>()
-    fun setFilter(ctx: Context) {
-        val sourceId = ctx.pathParam("sourceId").toLong()
-        val filterChange = ctx.bodyAsClass(FilterChange::class.java)
 
-        ctx.json(Search.setFilter(sourceId, filterChange))
+    /** change filters of source with id `sourceId` */
-    }
+    val setFilters = handler(
+        pathParam<Long>("sourceId"),
+        documentWith = {
+            withOperation {
+                summary("Source filters set")
+                description("Change filters of source with id `sourceId`")
+            }
+        },
+        behaviorOf = { ctx, sourceId ->
+            val filterChange = try {
+                json.decodeFromString<List<FilterChange>>(ctx.body())
+            } catch (e: Exception) {
+                listOf(json.decodeFromString<FilterChange>(ctx.body()))
+            }
+
+            ctx.json(Search.setFilter(sourceId, filterChange))
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+        }
+    )
 
     /** single source search */
-    fun searchSingle(ctx: Context) {
+    val searchSingle = handler(
-        val sourceId = ctx.pathParam("sourceId").toLong()
+        pathParam<Long>("sourceId"),
-        val searchTerm = ctx.queryParam("searchTerm") ?: ""
+        queryParam("searchTerm", ""),
-        val pageNum = ctx.queryParam("pageNum")?.toInt() ?: 1
+        queryParam("pageNum", 1),
-        ctx.future(future { Search.sourceSearch(sourceId, searchTerm, pageNum) })
+        documentWith = {
-    }
+            withOperation {
+                summary("Source search")
+                description("Single source search")
+            }
+        },
+        behaviorOf = { ctx, sourceId, searchTerm, pageNum ->
+            ctx.future(future { Search.sourceSearch(sourceId, searchTerm, pageNum) })
+        },
+        withResults = {
+            json<PagedMangaListDataClass>(HttpCode.OK)
+        }
+    )
 
     /** all source search */
-    fun searchAll(ctx: Context) { // TODO
+    val searchAll = handler(
-        val searchTerm = ctx.pathParam("searchTerm")
+        pathParam<String>("searchTerm"),
-        ctx.json(Search.sourceGlobalSearch(searchTerm))
+        documentWith = {
-    }
+            withOperation {
+                summary("Source global search")
+                description("All source search")
+            }
+        },
+        behaviorOf = { ctx, searchTerm -> // TODO
+            ctx.json(Search.sourceGlobalSearch(searchTerm))
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+        }
+    )
 }

server/src/main/kotlin/suwayomi/tachidesk/manga/controller/UpdateController.kt

@@ -1,6 +1,5 @@
 package suwayomi.tachidesk.manga.controller
 
-import io.javalin.http.Context
 import io.javalin.http.HttpCode
 import io.javalin.websocket.WsConfig
 import kotlinx.coroutines.runBlocking
@@ -12,10 +11,15 @@ import suwayomi.tachidesk.manga.impl.Category
 import suwayomi.tachidesk.manga.impl.CategoryManga
 import suwayomi.tachidesk.manga.impl.Chapter
 import suwayomi.tachidesk.manga.impl.update.IUpdater
+import suwayomi.tachidesk.manga.impl.update.UpdateStatus
 import suwayomi.tachidesk.manga.impl.update.UpdaterSocket
 import suwayomi.tachidesk.manga.model.dataclass.CategoryDataClass
+import suwayomi.tachidesk.manga.model.dataclass.MangaDataClass
+import suwayomi.tachidesk.manga.model.dataclass.PaginatedList
 import suwayomi.tachidesk.server.JavalinSetup.future
+import suwayomi.tachidesk.server.util.formParam
 import suwayomi.tachidesk.server.util.handler
+import suwayomi.tachidesk.server.util.pathParam
 import suwayomi.tachidesk.server.util.withOperation
 
 /*
@@ -29,35 +33,57 @@ object UpdateController {
     private val logger = KotlinLogging.logger { }
 
     /** get recently updated manga chapters */
-    fun recentChapters(ctx: Context) {
+    val recentChapters = handler(
-        val pageNum = ctx.pathParam("pageNum").toInt()
+        pathParam<Int>("pageNum"),
-
+        documentWith = {
-        ctx.future(
+            withOperation {
-            future {
+                summary("Updates fetch")
-                Chapter.getRecentChapters(pageNum)
+                description("Get recently updated manga chapters")
-            }
-        )
-    }
-
-    fun categoryUpdate(ctx: Context) {
-        val categoryId = ctx.formParam("category")?.toIntOrNull()
-        val categoriesForUpdate = ArrayList<CategoryDataClass>()
-        if (categoryId == null) {
-            logger.info { "Adding Library to Update Queue" }
-            categoriesForUpdate.addAll(Category.getCategoryList())
-        } else {
-            val category = Category.getCategoryById(categoryId)
-            if (category != null) {
-                categoriesForUpdate.add(category)
-            } else {
-                logger.info { "No Category found" }
-                ctx.status(HttpCode.BAD_REQUEST)
-                return
             }
+        },
+        behaviorOf = { ctx, pageNum ->
+            ctx.future(
+                future {
+                    Chapter.getRecentChapters(pageNum)
+                }
+            )
+        },
+        withResults = {
+            json<PaginatedList<MangaDataClass>>(HttpCode.OK)
         }
-        addCategoriesToUpdateQueue(categoriesForUpdate, true)
+    )
-        ctx.status(HttpCode.OK)
+
-    }
+    val categoryUpdate = handler(
+        formParam<Int?>("categoryId"),
+        documentWith = {
+            withOperation {
+                summary("Updater start")
+                description("Starts the updater")
+            }
+        },
+        behaviorOf = { ctx, categoryId ->
+            val categoriesForUpdate = ArrayList<CategoryDataClass>()
+            if (categoryId == null) {
+                logger.info { "Adding Library to Update Queue" }
+                categoriesForUpdate.addAll(Category.getCategoryList())
+            } else {
+                val category = Category.getCategoryById(categoryId)
+                if (category != null) {
+                    categoriesForUpdate.add(category)
+                } else {
+                    logger.info { "No Category found" }
+                    ctx.status(HttpCode.BAD_REQUEST)
+                    return@handler
+                }
+            }
+            addCategoriesToUpdateQueue(categoriesForUpdate, true)
+            ctx.status(HttpCode.OK)
+        },
+        withResults = {
+            httpCode(HttpCode.OK)
+            httpCode(HttpCode.BAD_REQUEST)
+        }
+    )
 
     private fun addCategoriesToUpdateQueue(categories: List<CategoryDataClass>, clear: Boolean = false) {
         val updater by DI.global.instance<IUpdater>()
@@ -84,15 +110,27 @@ object UpdateController {
         }
     }
 
-    fun updateSummary(ctx: Context) {
+    val updateSummary = handler(
-        val updater by DI.global.instance<IUpdater>()
+        documentWith = {
-        ctx.json(updater.getStatus().value.getJsonSummary())
+            withOperation {
-    }
+                summary("Updater summary")
+                description("Gets the latest updater summary")
+            }
+        },
+        behaviorOf = { ctx ->
+            val updater by DI.global.instance<IUpdater>()
+            ctx.json(updater.getStatus().value.getJsonSummary())
+        },
+        withResults = {
+            json<UpdateStatus>(HttpCode.OK)
+        }
+    )
 
     val reset = handler(
         documentWith = {
             withOperation {
-                summary("Stops and resets the Updater")
+                summary("Updater reset")
+                description("Stops and resets the Updater")
             }
         },
         behaviorOf = { ctx ->

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/CategoryManga.kt

@@ -70,12 +70,19 @@ object CategoryManga {
                 .slice(ChapterTable.id.count())
                 .select { (MangaTable.id eq ChapterTable.manga) and (ChapterTable.isDownloaded eq true) }
         )
+        val chapterCountExpression = wrapAsExpression<Long>(
+            ChapterTable
+                .slice(ChapterTable.id.count())
+                .select { (MangaTable.id eq ChapterTable.manga) }
+        )
+
+        val selectedColumns = MangaTable.columns + unreadExpression + downloadExpression + chapterCountExpression
 
-        val selectedColumns = MangaTable.columns + unreadExpression + downloadExpression
         val transform: (ResultRow) -> MangaDataClass = {
             val dataClass = MangaTable.toDataClass(it)
             dataClass.unreadCount = it[unreadExpression]?.toInt()
             dataClass.downloadCount = it[downloadExpression]?.toInt()
+            dataClass.chapterCount = it[chapterCountExpression]?.toInt()
             dataClass
         }
 
@@ -90,7 +97,7 @@ object CategoryManga {
         return transaction {
             CategoryMangaTable.innerJoin(MangaTable)
                 .slice(selectedColumns)
-                .select { CategoryMangaTable.category eq categoryId }
+                .select { (MangaTable.inLibrary eq true) and (CategoryMangaTable.category eq categoryId) }
                 .map(transform)
         }
     }

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/Chapter.kt

@@ -201,8 +201,10 @@ object Chapter {
             val chapterId =
                 ChapterTable.select { (ChapterTable.manga eq mangaId) and (ChapterTable.sourceOrder eq chapterIndex) }
                     .first()[ChapterTable.id].value
-            val meta =
+            val meta = transaction {
-                transaction { ChapterMetaTable.select { (ChapterMetaTable.ref eq chapterId) and (ChapterMetaTable.key eq key) } }.firstOrNull()
+                ChapterMetaTable.select { (ChapterMetaTable.ref eq chapterId) and (ChapterMetaTable.key eq key) }
+            }.firstOrNull()
+
             if (meta == null) {
                 ChapterMetaTable.insert {
                     it[ChapterMetaTable.key] = key
@@ -210,7 +212,7 @@ object Chapter {
                     it[ChapterMetaTable.ref] = chapterId
                 }
             } else {
-                ChapterMetaTable.update {
+                ChapterMetaTable.update({ (ChapterMetaTable.ref eq chapterId) and (ChapterMetaTable.key eq key) }) {
                     it[ChapterMetaTable.value] = value
                 }
             }

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/Library.kt

@@ -7,7 +7,6 @@ package suwayomi.tachidesk.manga.impl
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-import org.jetbrains.exposed.sql.deleteWhere
 import org.jetbrains.exposed.sql.insert
 import org.jetbrains.exposed.sql.select
 import org.jetbrains.exposed.sql.transactions.transaction
@@ -24,17 +23,20 @@ object Library {
         if (!manga.inLibrary) {
             transaction {
                 val defaultCategories = CategoryTable.select { CategoryTable.isDefault eq true }.toList()
+                val existingCategories = CategoryMangaTable.select { CategoryMangaTable.manga eq mangaId }.toList()
 
                 MangaTable.update({ MangaTable.id eq manga.id }) {
                     it[inLibrary] = true
                     it[inLibraryAt] = Instant.now().epochSecond
-                    it[defaultCategory] = defaultCategories.isEmpty()
+                    it[defaultCategory] = defaultCategories.isEmpty() && existingCategories.isEmpty()
                 }
 
-                defaultCategories.forEach { category ->
+                if (existingCategories.isEmpty()) {
-                    CategoryMangaTable.insert {
+                    defaultCategories.forEach { category ->
-                        it[CategoryMangaTable.category] = category[CategoryTable.id].value
+                        CategoryMangaTable.insert {
-                        it[CategoryMangaTable.manga] = mangaId
+                            it[CategoryMangaTable.category] = category[CategoryTable.id].value
+                            it[CategoryMangaTable.manga] = mangaId
+                        }
                     }
                 }
             }
@@ -47,9 +49,7 @@ object Library {
             transaction {
                 MangaTable.update({ MangaTable.id eq manga.id }) {
                     it[inLibrary] = false
-                    it[defaultCategory] = true
                 }
-                CategoryMangaTable.deleteWhere { CategoryMangaTable.manga eq mangaId }
             }
         }
     }

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/Manga.kt

@@ -8,9 +8,11 @@ package suwayomi.tachidesk.manga.impl
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.NetworkHelper
 import eu.kanade.tachiyomi.source.local.LocalSource
 import eu.kanade.tachiyomi.source.model.SManga
 import eu.kanade.tachiyomi.source.online.HttpSource
+import org.jetbrains.exposed.sql.ResultRow
 import org.jetbrains.exposed.sql.and
 import org.jetbrains.exposed.sql.insert
 import org.jetbrains.exposed.sql.select
@@ -23,7 +25,9 @@ import suwayomi.tachidesk.manga.impl.MangaList.proxyThumbnailUrl
 import suwayomi.tachidesk.manga.impl.Source.getSource
 import suwayomi.tachidesk.manga.impl.util.lang.awaitSingle
 import suwayomi.tachidesk.manga.impl.util.network.await
+import suwayomi.tachidesk.manga.impl.util.source.GetCatalogueSource.getCatalogueSourceOrNull
 import suwayomi.tachidesk.manga.impl.util.source.GetCatalogueSource.getCatalogueSourceOrStub
+import suwayomi.tachidesk.manga.impl.util.source.StubSource
 import suwayomi.tachidesk.manga.impl.util.storage.ImageResponse.clearCachedImage
 import suwayomi.tachidesk.manga.impl.util.storage.ImageResponse.getImageResponse
 import suwayomi.tachidesk.manga.impl.util.storage.ImageUtil
@@ -34,6 +38,7 @@ import suwayomi.tachidesk.manga.model.table.MangaMetaTable
 import suwayomi.tachidesk.manga.model.table.MangaStatus
 import suwayomi.tachidesk.manga.model.table.MangaTable
 import suwayomi.tachidesk.server.ApplicationDirs
+import uy.kohesive.injekt.injectLazy
 import java.io.File
 import java.io.IOException
 import java.io.InputStream
@@ -50,30 +55,10 @@ object Manga {
         var mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.first() }
 
         return if (mangaEntry[MangaTable.initialized] && !onlineFetch) {
-            MangaDataClass(
+            getMangaDataClass(mangaId, mangaEntry)
-                mangaId,
-                mangaEntry[MangaTable.sourceReference].toString(),
-
-                mangaEntry[MangaTable.url],
-                mangaEntry[MangaTable.title],
-                proxyThumbnailUrl(mangaId),
-
-                true,
-
-                mangaEntry[MangaTable.artist],
-                mangaEntry[MangaTable.author],
-                mangaEntry[MangaTable.description],
-                mangaEntry[MangaTable.genre].toGenreList(),
-                MangaStatus.valueOf(mangaEntry[MangaTable.status]).name,
-                mangaEntry[MangaTable.inLibrary],
-                mangaEntry[MangaTable.inLibraryAt],
-                getSource(mangaEntry[MangaTable.sourceReference]),
-                getMangaMetaMap(mangaId),
-                mangaEntry[MangaTable.realUrl],
-                false
-            )
         } else { // initialize manga
-            val source = getCatalogueSourceOrStub(mangaEntry[MangaTable.sourceReference])
+            val source = getCatalogueSourceOrNull(mangaEntry[MangaTable.sourceReference])
+                ?: return getMangaDataClass(mangaId, mangaEntry)
             val sManga = SManga.create().apply {
                 url = mangaEntry[MangaTable.url]
                 title = mangaEntry[MangaTable.title]
@@ -135,6 +120,29 @@ object Manga {
         }
     }
 
+    private fun getMangaDataClass(mangaId: Int, mangaEntry: ResultRow) = MangaDataClass(
+        mangaId,
+        mangaEntry[MangaTable.sourceReference].toString(),
+
+        mangaEntry[MangaTable.url],
+        mangaEntry[MangaTable.title],
+        proxyThumbnailUrl(mangaId),
+
+        true,
+
+        mangaEntry[MangaTable.artist],
+        mangaEntry[MangaTable.author],
+        mangaEntry[MangaTable.description],
+        mangaEntry[MangaTable.genre].toGenreList(),
+        MangaStatus.valueOf(mangaEntry[MangaTable.status]).name,
+        mangaEntry[MangaTable.inLibrary],
+        mangaEntry[MangaTable.inLibraryAt],
+        getSource(mangaEntry[MangaTable.sourceReference]),
+        getMangaMetaMap(mangaId),
+        mangaEntry[MangaTable.realUrl],
+        false
+    )
+
     fun getMangaMetaMap(manga: Int): Map<String, String> {
         return transaction {
             MangaMetaTable.select { MangaMetaTable.ref eq manga }
@@ -146,8 +154,10 @@ object Manga {
         transaction {
             val manga = MangaTable.select { MangaTable.id eq mangaId }
                 .first()[MangaTable.id]
-            val meta =
+            val meta = transaction {
-                transaction { MangaMetaTable.select { (MangaMetaTable.ref eq manga) and (MangaMetaTable.key eq key) } }.firstOrNull()
+                MangaMetaTable.select { (MangaMetaTable.ref eq manga) and (MangaMetaTable.key eq key) }
+            }.firstOrNull()
+
             if (meta == null) {
                 MangaMetaTable.insert {
                     it[MangaMetaTable.key] = key
@@ -155,7 +165,7 @@ object Manga {
                     it[MangaMetaTable.ref] = manga
                 }
             } else {
-                MangaMetaTable.update {
+                MangaMetaTable.update({ (MangaMetaTable.ref eq manga) and (MangaMetaTable.key eq key) }) {
                     it[MangaMetaTable.value] = value
                 }
             }
@@ -163,6 +173,7 @@ object Manga {
     }
 
     private val applicationDirs by DI.global.instance<ApplicationDirs>()
+    private val network: NetworkHelper by injectLazy()
     suspend fun getMangaThumbnail(mangaId: Int, useCache: Boolean): Pair<InputStream, String> {
         val saveDir = applicationDirs.thumbnailsRoot
         val fileName = mangaId.toString()
@@ -176,10 +187,12 @@ object Manga {
                     ?: if (!mangaEntry[MangaTable.initialized]) {
                         // initialize then try again
                         getManga(mangaId)
-                        transaction { MangaTable.select { MangaTable.id eq mangaId }.first() }[MangaTable.thumbnail_url]!!
+                        transaction {
+                            MangaTable.select { MangaTable.id eq mangaId }.first()
+                        }[MangaTable.thumbnail_url]!!
                     } else {
                         // source provides no thumbnail url for this manga
-                        throw NullPointerException()
+                        throw NullPointerException("No thumbnail found")
                     }
 
                 source.client.newCall(
@@ -199,6 +212,13 @@ object Manga {
                     ?: "image/jpeg"
                 imageFile.inputStream() to contentType
             }
+            is StubSource -> getImageResponse(saveDir, fileName, useCache) {
+                val thumbnailUrl = mangaEntry[MangaTable.thumbnail_url]
+                    ?: throw NullPointerException("No thumbnail found")
+                network.client.newCall(
+                    GET(thumbnailUrl)
+                ).await()
+            }
             else -> throw IllegalArgumentException("Unknown source")
         }
     }

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/Search.kt

@@ -11,6 +11,7 @@ import eu.kanade.tachiyomi.source.CatalogueSource
 import eu.kanade.tachiyomi.source.model.Filter
 import eu.kanade.tachiyomi.source.model.FilterList
 import io.javalin.plugin.json.JsonMapper
+import kotlinx.serialization.Serializable
 import org.kodein.di.DI
 import org.kodein.di.conf.global
 import org.kodein.di.instance
@@ -80,37 +81,42 @@ object Search {
         val filter: Filter<*>,
     )
 
-    fun setFilter(sourceId: Long, change: FilterChange) {
+    fun setFilter(sourceId: Long, changes: List<FilterChange>) {
         val source = getCatalogueSourceOrStub(sourceId)
         val filterList = getFilterListOf(source, false)
 
-        when (val filter = filterList[change.position]) {
+        changes.forEach { change ->
-            is Filter.Header -> {
+            when (val filter = filterList[change.position]) {
-                // NOOP
+                is Filter.Header -> {
-            }
+                    // NOOP
-            is Filter.Separator -> {
+                }
-                // NOOP
+                is Filter.Separator -> {
-            }
+                    // NOOP
-            is Filter.Select<*> -> filter.state = change.state.toInt()
+                }
-            is Filter.Text -> filter.state = change.state
+                is Filter.Select<*> -> filter.state = change.state.toInt()
-            is Filter.CheckBox -> filter.state = change.state.toBooleanStrict()
+                is Filter.Text -> filter.state = change.state
-            is Filter.TriState -> filter.state = change.state.toInt()
+                is Filter.CheckBox -> filter.state = change.state.toBooleanStrict()
-            is Filter.Group<*> -> {
+                is Filter.TriState -> filter.state = change.state.toInt()
-                val groupChange = jsonMapper.fromJsonString(change.state, FilterChange::class.java)
+                is Filter.Group<*> -> {
+                    val groupChange = jsonMapper.fromJsonString(change.state, FilterChange::class.java)
 
-                when (val groupFilter = filter.state[groupChange.position]) {
+                    when (val groupFilter = filter.state[groupChange.position]) {
-                    is Filter.CheckBox -> groupFilter.state = groupChange.state.toBooleanStrict()
+                        is Filter.CheckBox -> groupFilter.state = groupChange.state.toBooleanStrict()
-                    is Filter.TriState -> groupFilter.state = groupChange.state.toInt()
+                        is Filter.TriState -> groupFilter.state = groupChange.state.toInt()
-                    is Filter.Text -> groupFilter.state = groupChange.state
+                        is Filter.Text -> groupFilter.state = groupChange.state
-                    is Filter.Select<*> -> groupFilter.state = groupChange.state.toInt()
+                        is Filter.Select<*> -> groupFilter.state = groupChange.state.toInt()
+                    }
+                }
+                is Filter.Sort -> {
+                    filter.state = jsonMapper.fromJsonString(change.state, Filter.Sort.Selection::class.java)
                 }
             }
-            is Filter.Sort -> filter.state = jsonMapper.fromJsonString(change.state, Filter.Sort.Selection::class.java)
         }
     }
 
     private val jsonMapper by DI.global.instance<JsonMapper>()
 
+    @Serializable
     data class FilterChange(
         val position: Int,
         val state: String

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/Source.kt

@@ -21,7 +21,7 @@ import org.kodein.di.DI
 import org.kodein.di.conf.global
 import org.kodein.di.instance
 import suwayomi.tachidesk.manga.impl.extension.Extension.getExtensionIconUrl
-import suwayomi.tachidesk.manga.impl.util.source.GetCatalogueSource.getCatalogueSource
+import suwayomi.tachidesk.manga.impl.util.source.GetCatalogueSource.getCatalogueSourceOrNull
 import suwayomi.tachidesk.manga.impl.util.source.GetCatalogueSource.getCatalogueSourceOrStub
 import suwayomi.tachidesk.manga.impl.util.source.GetCatalogueSource.unregisterCatalogueSource
 import suwayomi.tachidesk.manga.model.dataclass.SourceDataClass
@@ -36,8 +36,8 @@ object Source {
 
     fun getSourceList(): List<SourceDataClass> {
         return transaction {
-            SourceTable.selectAll().map {
+            SourceTable.selectAll().mapNotNull {
-                val catalogueSource = getCatalogueSourceOrStub(it[SourceTable.id].value)
+                val catalogueSource = getCatalogueSourceOrNull(it[SourceTable.id].value) ?: return@mapNotNull null
                 val sourceExtension = ExtensionTable.select { ExtensionTable.id eq it[SourceTable.extension] }.first()
 
                 SourceDataClass(
@@ -54,27 +54,23 @@ object Source {
         }
     }
 
-    fun getSource(sourceId: Long): SourceDataClass { // all the data extracted fresh form the source instance
+    fun getSource(sourceId: Long): SourceDataClass? { // all the data extracted fresh form the source instance
         return transaction {
-            val source = SourceTable.select { SourceTable.id eq sourceId }.firstOrNull()
+            val source = SourceTable.select { SourceTable.id eq sourceId }.firstOrNull() ?: return@transaction null
-            val catalogueSource = source?.let { getCatalogueSource(sourceId) }
+            val catalogueSource = getCatalogueSourceOrNull(sourceId) ?: return@transaction null
-            val extension = source?.let {
+            val extension = ExtensionTable.select { ExtensionTable.id eq source[SourceTable.extension] }.first()
-                ExtensionTable.select { ExtensionTable.id eq source[SourceTable.extension] }.first()
-            }
 
             SourceDataClass(
                 sourceId.toString(),
-                source?.get(SourceTable.name),
+                source[SourceTable.name],
-                source?.get(SourceTable.lang),
+                source[SourceTable.lang],
-                source?.let {
+                getExtensionIconUrl(
-                    getExtensionIconUrl(
+                    extension[ExtensionTable.apkName]
-                        extension!![ExtensionTable.apkName]
+                ),
-                    )
+                catalogueSource.supportsLatest,
-                },
+                catalogueSource is ConfigurableSource,
-                catalogueSource?.supportsLatest,
+                source[SourceTable.isNsfw],
-                catalogueSource?.let { it is ConfigurableSource },
+                catalogueSource.toString()
-                source?.get(SourceTable.isNsfw),
-                catalogueSource?.toString()
             )
         }
     }

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/util/PackageTools.kt

@@ -41,7 +41,7 @@ object PackageTools {
     const val METADATA_SOURCE_FACTORY = "tachiyomi.extension.factory"
     const val METADATA_NSFW = "tachiyomi.extension.nsfw"
     const val LIB_VERSION_MIN = 1.2
-    const val LIB_VERSION_MAX = 1.2
+    const val LIB_VERSION_MAX = 1.3
 
     private const val officialSignature = "7ce04da7773d41b489f4693a366c36bcd0a11fc39b547168553c285bd7348e23" // inorichi's key
     private const val unofficialSignature = "64feb21075ba97ebc9cc981243645b331595c111cef1b0d084236a0403b00581" // ArMor's key

server/src/main/kotlin/suwayomi/tachidesk/manga/impl/util/source/GetCatalogueSource.kt

@@ -26,7 +26,7 @@ object GetCatalogueSource {
     private val sourceCache = ConcurrentHashMap<Long, CatalogueSource>()
     private val applicationDirs by DI.global.instance<ApplicationDirs>()
 
-    fun getCatalogueSource(sourceId: Long): CatalogueSource? {
+    private fun getCatalogueSource(sourceId: Long): CatalogueSource? {
         val cachedResult: CatalogueSource? = sourceCache[sourceId]
         if (cachedResult != null) {
             return cachedResult
@@ -56,8 +56,12 @@ object GetCatalogueSource {
         return sourceCache[sourceId]!!
     }
 
+    fun getCatalogueSourceOrNull(sourceId: Long): CatalogueSource? {
+        return runCatching { getCatalogueSource(sourceId) }.getOrNull()
+    }
+
     fun getCatalogueSourceOrStub(sourceId: Long): CatalogueSource {
-        return getCatalogueSource(sourceId) ?: StubSource(sourceId)
+        return getCatalogueSourceOrNull(sourceId) ?: StubSource(sourceId)
     }
 
     fun registerCatalogueSource(sourcePair: Pair<Long, CatalogueSource>) {

server/src/main/kotlin/suwayomi/tachidesk/manga/model/dataclass/MangaDataClass.kt

@@ -36,7 +36,8 @@ data class MangaDataClass(
 
     val freshData: Boolean = false,
     var unreadCount: Int? = null,
-    var downloadCount: Int? = null
+    var downloadCount: Int? = null,
+    var chapterCount: Int? = null
 )
 
 data class PagedMangaListDataClass(

server/src/main/kotlin/suwayomi/tachidesk/manga/model/dataclass/SourceDataClass.kt

@@ -11,19 +11,19 @@ import eu.kanade.tachiyomi.source.ConfigurableSource
 
 data class SourceDataClass(
     val id: String,
-    val name: String?,
+    val name: String,
-    val lang: String?,
+    val lang: String,
-    val iconUrl: String?,
+    val iconUrl: String,
 
     /** The Source provides a latest listing */
-    val supportsLatest: Boolean?,
+    val supportsLatest: Boolean,
 
     /** The Source implements [ConfigurableSource] */
-    val isConfigurable: Boolean?,
+    val isConfigurable: Boolean,
 
     /** The Source class has a @Nsfw annotation */
-    val isNsfw: Boolean?,
+    val isNsfw: Boolean,
 
     /** A nicer version of [name] */
-    val displayName: String?,
+    val displayName: String,
 )

server/src/main/kotlin/suwayomi/tachidesk/manga/model/table/MangaTable.kt

@@ -66,7 +66,10 @@ enum class MangaStatus(val value: Int) {
     UNKNOWN(0),
     ONGOING(1),
     COMPLETED(2),
-    LICENSED(3);
+    LICENSED(3),
+    PUBLISHING_FINISHED(4),
+    CANCELLED(5),
+    ON_HIATUS(6);
 
     companion object {
         fun valueOf(value: Int): MangaStatus = values().find { it.value == value } ?: UNKNOWN

server/src/main/kotlin/suwayomi/tachidesk/server/JavalinSetup.kt

@@ -26,7 +26,7 @@ import org.kodein.di.instance
 import suwayomi.tachidesk.global.GlobalAPI
 import suwayomi.tachidesk.manga.MangaAPI
 import suwayomi.tachidesk.server.util.Browser
-import suwayomi.tachidesk.server.util.setupWebUI
+import suwayomi.tachidesk.server.util.setupWebInterface
 import java.io.IOException
 import java.util.concurrent.CompletableFuture
 import kotlin.concurrent.thread
@@ -45,15 +45,29 @@ object JavalinSetup {
     fun javalinSetup() {
         val app = Javalin.create { config ->
             if (serverConfig.webUIEnabled) {
-                setupWebUI()
+                setupWebInterface()
 
-                logger.info { "Serving webUI static files" }
+                logger.info { "Serving web static files for ${serverConfig.webUIFlavor}" }
                 config.addStaticFiles(applicationDirs.webUIRoot, Location.EXTERNAL)
                 config.addSinglePageRoot("/", applicationDirs.webUIRoot + "/index.html", Location.EXTERNAL)
                 config.registerPlugin(OpenApiPlugin(getOpenApiOptions()))
             }
 
             config.enableCorsForAllOrigins()
+
+            config.accessManager { handler, ctx, _ ->
+                fun credentialsValid(): Boolean {
+                    val (username, password) = ctx.basicAuthCredentials()
+                    return username == serverConfig.basicAuthUsername && password == serverConfig.basicAuthPassword
+                }
+
+                if (serverConfig.basicAuthEnabled && !(ctx.basicAuthCredentialsExist() && credentialsValid())) {
+                    ctx.header("WWW-Authenticate", "Basic")
+                    ctx.status(401).json("Unauthorized")
+                } else {
+                    handler.handle(ctx)
+                }
+            }
         }.events { event ->
             event.serverStarted {
                 if (serverConfig.initialOpenInBrowserEnabled) {
@@ -83,18 +97,6 @@ object JavalinSetup {
             ctx.result(e.message ?: "Internal Server Error")
         }
 
-        app.before { ctx ->
-            fun credentialsValid(): Boolean {
-                val (username, password) = ctx.basicAuthCredentials()
-                return username == serverConfig.basicAuthUsername && password == serverConfig.basicAuthPassword
-            }
-
-            if (serverConfig.basicAuthEnabled && !(ctx.basicAuthCredentialsExist() && credentialsValid())) {
-                ctx.header("WWW-Authenticate", "Basic")
-                ctx.status(401).json("Unauthorized")
-            }
-        }
-
         app.routes {
             path("api/v1/") {
                 GlobalAPI.defineEndpoints()

server/src/main/kotlin/suwayomi/tachidesk/server/ServerConfig.kt

@@ -26,9 +26,11 @@ class ServerConfig(config: Config, moduleName: String = MODULE_NAME) : SystemPro
     // misc
     val debugLogsEnabled: Boolean = debugLogsEnabled(GlobalConfigManager.config)
     val systemTrayEnabled: Boolean by overridableConfig
+    val downloadsPath: String by overridableConfig
 
     // webUI
     val webUIEnabled: Boolean by overridableConfig
+    val webUIFlavor: String by overridableConfig
     val initialOpenInBrowserEnabled: Boolean by overridableConfig
     val webUIInterface: String by overridableConfig
     val electronPath: String by overridableConfig

server/src/main/kotlin/suwayomi/tachidesk/server/ServerSetup.kt

@@ -11,7 +11,9 @@ import eu.kanade.tachiyomi.App
 import eu.kanade.tachiyomi.source.local.LocalSource
 import io.javalin.plugin.json.JavalinJackson
 import io.javalin.plugin.json.JsonMapper
+import kotlinx.serialization.json.Json
 import mu.KotlinLogging
+import org.bouncycastle.jce.provider.BouncyCastleProvider
 import org.kodein.di.DI
 import org.kodein.di.bind
 import org.kodein.di.conf.global
@@ -28,6 +30,7 @@ import xyz.nulldev.ts.config.ApplicationRootDir
 import xyz.nulldev.ts.config.ConfigKodeinModule
 import xyz.nulldev.ts.config.GlobalConfigManager
 import java.io.File
+import java.security.Security
 import java.util.Locale
 
 private val logger = KotlinLogging.logger {}
@@ -37,7 +40,7 @@ class ApplicationDirs(
 ) {
     val extensionsRoot = "$dataRoot/extensions"
     val thumbnailsRoot = "$dataRoot/thumbnails"
-    val mangaDownloadsRoot = "$dataRoot/downloads"
+    val mangaDownloadsRoot = serverConfig.downloadsPath.ifBlank { "$dataRoot/downloads" }
     val localMangaRoot = "$dataRoot/local"
     val webUIRoot = "$dataRoot/webUI"
 }
@@ -51,6 +54,11 @@ val androidCompat by lazy { AndroidCompat() }
 fun applicationSetup() {
     logger.info("Running Tachidesk ${BuildConfig.VERSION} revision ${BuildConfig.REVISION}")
 
+    // register Tachidesk's config which is dubbed "ServerConfig"
+    GlobalConfigManager.registerModule(
+        ServerConfig.register(GlobalConfigManager.config)
+    )
+
     // Application dirs
     val applicationDirs = ApplicationDirs()
 
@@ -59,6 +67,7 @@ fun applicationSetup() {
             bind<ApplicationDirs>() with singleton { applicationDirs }
             bind<IUpdater>() with singleton { Updater() }
             bind<JsonMapper>() with singleton { JavalinJackson() }
+            bind<Json>() with singleton { Json { ignoreUnknownKeys = true } }
         }
     )
 
@@ -67,7 +76,6 @@ fun applicationSetup() {
     // Migrate Directories from old versions
     File("$ApplicationRootDir/manga-thumbnails").renameTo(applicationDirs.thumbnailsRoot)
     File("$ApplicationRootDir/manga-local").renameTo(applicationDirs.localMangaRoot)
-    File("$ApplicationRootDir/manga").renameTo(applicationDirs.mangaDownloadsRoot)
     File("$ApplicationRootDir/anime-thumbnails").delete()
 
     // make dirs we need
@@ -82,11 +90,6 @@ fun applicationSetup() {
         File(it).mkdirs()
     }
 
-    // register Tachidesk's config which is dubbed "ServerConfig"
-    GlobalConfigManager.registerModule(
-        ServerConfig.register(GlobalConfigManager.config)
-    )
-
     // Make sure only one instance of the app is running
     handleAppMutex()
 
@@ -152,4 +155,7 @@ fun applicationSetup() {
         System.getProperties()["socksProxyPort"] = serverConfig.socksProxyPort
         logger.info("Socks Proxy is enabled to ${serverConfig.socksProxyHost}:${serverConfig.socksProxyPort}")
     }
+
+    // AES/CBC/PKCS7Padding Cypher provider for zh.copymanga
+    Security.addProvider(BouncyCastleProvider())
 }

server/src/main/kotlin/suwayomi/tachidesk/server/util/DocumentationDsl.kt

@@ -113,7 +113,7 @@ sealed class Param<T> {
 }
 
 class ResultsBuilder {
-    val results = mutableListOf<ResultType<*>>()
+    val results = mutableListOf<ResultType>()
 
     inline fun <reified T> json(code: HttpCode) {
         results += ResultType.MimeType(code, "application/json", T::class.java)
@@ -121,19 +121,22 @@ class ResultsBuilder {
     fun plainText(code: HttpCode) {
         results += ResultType.MimeType(code, "text/plain", String::class.java)
     }
+    fun mime(code: HttpCode, mime: String) {
+        results += ResultType.MimeType(code, mime, null)
+    }
     fun httpCode(code: HttpCode) {
         results += ResultType.StatusCode(code)
     }
 }
 
-sealed class ResultType <T> {
+sealed class ResultType {
     abstract fun applyTo(documentation: OpenApiDocumentation)
-    data class MimeType<T>(val code: HttpCode, val mime: String, private val clazz: Class<T>) : ResultType<T>() {
+    data class MimeType(val code: HttpCode, val mime: String, private val clazz: Class<*>?) : ResultType() {
         override fun applyTo(documentation: OpenApiDocumentation) {
             documentation.result(code.status.toString(), clazz)
         }
     }
-    data class StatusCode(val code: HttpCode) : ResultType<Unit>() {
+    data class StatusCode(val code: HttpCode) : ResultType() {
         override fun applyTo(documentation: OpenApiDocumentation) {
             documentation.result<Unit>(code.status.toString())
         }

server/src/main/kotlin/suwayomi/tachidesk/server/util/WebInterfaceManager.kt

@@ -7,6 +7,9 @@ package suwayomi.tachidesk.server.util
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
 import mu.KotlinLogging
 import net.lingala.zip4j.ZipFile
 import org.kodein.di.DI
@@ -14,6 +17,8 @@ import org.kodein.di.conf.global
 import org.kodein.di.instance
 import suwayomi.tachidesk.server.ApplicationDirs
 import suwayomi.tachidesk.server.BuildConfig
+import suwayomi.tachidesk.server.serverConfig
+import uy.kohesive.injekt.injectLazy
 import java.io.File
 import java.io.InputStream
 import java.net.HttpURLConnection
@@ -23,6 +28,7 @@ import java.security.MessageDigest
 
 private val logger = KotlinLogging.logger {}
 private val applicationDirs by DI.global.instance<ApplicationDirs>()
+private val json: Json by injectLazy()
 private val tmpDir = System.getProperty("java.io.tmpdir")
 
 private fun ByteArray.toHex(): String = joinToString(separator = "") { eachByte -> "%02x".format(eachByte) }
@@ -44,6 +50,19 @@ private fun directoryMD5(fileDir: String): String {
     return digest.toHex()
 }
 
+/** Make sure a valid web interface installation is available */
+fun setupWebInterface() {
+    when (serverConfig.webUIFlavor) {
+        "WebUI" -> setupWebUI()
+        "Sorayomi" -> setupSorayomi()
+        "Custom" -> {
+            /* do nothing */
+        }
+        else -> setupWebUI()
+    }
+}
+
+/** Make sure a valid copy of WebUI is available */
 fun setupWebUI() {
     // check if we have webUI installed and is correct version
     val webUIRevisionFile = File(applicationDirs.webUIRoot + "/revision")
@@ -117,3 +136,63 @@ fun setupWebUI() {
         logger.info { "Extracting WebUI zip Done." }
     }
 }
+
+/** Make sure a valid copy of Sorayomi is available */
+fun setupSorayomi() {
+    // check if we have Sorayomi installed and is correct version
+    val sorayomiVersionFile = File(applicationDirs.webUIRoot + "/version.json")
+    if (sorayomiVersionFile.exists() && json.parseToJsonElement(
+            sorayomiVersionFile.readText()
+        ).jsonObject["version"]!!.jsonPrimitive.content == BuildConfig.SORAYOMI_TAG
+    ) {
+        logger.info { "Sorayomi Static files exists and is the correct revision" }
+        logger.info { "Verifying Sorayomi Static files..." }
+        logger.info { "md5: " + directoryMD5(applicationDirs.webUIRoot) }
+    } else {
+        File(applicationDirs.webUIRoot).deleteRecursively()
+
+        val sorayomiZip = "tachidesk-sorayomi-${BuildConfig.SORAYOMI_TAG}-web.zip"
+        val sorayomiZipPath = "$tmpDir/$sorayomiZip"
+        val sorayomiZipFile = File(sorayomiZipPath)
+
+        // download sorayomi zip
+        val sorayomiZipURL = "${BuildConfig.SORAYOMI_REPO}/releases/download/${BuildConfig.SORAYOMI_TAG}/$sorayomiZip"
+        sorayomiZipFile.delete()
+
+        logger.info { "Downloading Sorayomi zip from the Internet..." }
+        val data = ByteArray(1024)
+
+        sorayomiZipFile.outputStream().use { sorayomiZipFileOut ->
+
+            val connection = URL(sorayomiZipURL).openConnection() as HttpURLConnection
+            connection.connect()
+            val contentLength = connection.contentLength
+
+            connection.inputStream.buffered().use { inp ->
+                var totalCount = 0
+
+                print("Download progress: % 00")
+                while (true) {
+                    val count = inp.read(data, 0, 1024)
+
+                    if (count == -1)
+                        break
+
+                    totalCount += count
+                    val percentage = (totalCount.toFloat() / contentLength * 100).toInt().toString().padStart(2, '0')
+                    print("\b\b$percentage")
+
+                    sorayomiZipFileOut.write(data, 0, count)
+                }
+                println()
+                logger.info { "Downloading Sorayomi Done." }
+            }
+        }
+
+        // extract Sorayomi zip
+        logger.info { "Extracting Sorayomi zip..." }
+        File(applicationDirs.webUIRoot).mkdirs()
+        ZipFile(sorayomiZipPath).extractAll(applicationDirs.webUIRoot)
+        logger.info { "Extracting Sorayomi zip Done." }
+    }
+}

server/src/main/resources/server-reference.conf

@@ -9,6 +9,7 @@ server.socksProxyPort = ""
 
 # webUI
 server.webUIEnabled = true
+server.webUIFlavor = "WebUI" # "WebUI" or "Sorayomi" or "Custom"
 server.initialOpenInBrowserEnabled = true
 server.webUIInterface = "browser" # "browser" or "electron"
 server.electronPath = ""
@@ -21,3 +22,4 @@ server.basicAuthPassword = ""
 # misc
 server.debugLogsEnabled = false
 server.systemTrayEnabled = true
+server.downloadsPath = ""

server/src/test/kotlin/masstest/TestExtensionCompatibility.kt

@@ -27,7 +27,7 @@ import suwayomi.tachidesk.manga.impl.extension.Extension.uninstallExtension
 import suwayomi.tachidesk.manga.impl.extension.Extension.updateExtension
 import suwayomi.tachidesk.manga.impl.extension.ExtensionsList.getExtensionList
 import suwayomi.tachidesk.manga.impl.util.lang.awaitSingle
-import suwayomi.tachidesk.manga.impl.util.source.GetCatalogueSource.getCatalogueSource
+import suwayomi.tachidesk.manga.impl.util.source.GetCatalogueSource.getCatalogueSourceOrNull
 import suwayomi.tachidesk.manga.model.dataclass.ExtensionDataClass
 import suwayomi.tachidesk.server.applicationSetup
 import suwayomi.tachidesk.test.BASE_PATH
@@ -72,7 +72,7 @@ class TestExtensionCompatibility {
                     }
                 }
             }
-            sources = getSourceList().map { getCatalogueSource(it.id.toLong())!! as HttpSource }
+            sources = getSourceList().map { getCatalogueSourceOrNull(it.id.toLong())!! as HttpSource }
         }
         setLoggingEnabled(true)
         File("$BASE_PATH/sources.txt").writeText(sources.joinToString("\n") { "${it.name} - ${it.lang.uppercase()} - ${it.id}" })