update discord invite

Fix white screen if the manga doesn't have genre.

.github/scripts/commit-repo.sh

@@ -1,24 +1,19 @@
 #!/bin/bash
 
-git lfs install
-#git lfs track "*.zip"
+cp master/server/build/Tachidesk-*.jar preview
+cd preview
 
-cp ../master/repo/* .
 new_jar_build=$(ls *.jar| tail -1)
 echo "last jar build file name: $new_jar_build"
 
-new_win32_build=$(ls *.zip| tail -1)
-echo "last win32 build file name: $new_win32_build"
-
 cp -f $new_jar_build Tachidesk-latest.jar
-cp -f $new_win32_build Tachidesk-latest-win32.zip
 
 git config --global user.email "github-actions[bot]@users.noreply.github.com"
 git config --global user.name "github-actions[bot]"
 git status
 if [ -n "$(git status --porcelain)" ]; then
     git add .
-    git commit -m "Update repo"
+    git commit -m "Update preview repository"
     git push
 else
     echo "No changes to commit"

.github/scripts/create-repo.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-# Get last commit message
-#last_commit_log=$(git log -1 --pretty=format:"%s")
-#echo "last commit log: $last_commit_log"
-#
-#filter_count=$(echo "$last_commit_log" | grep -e '\[RELEASE CI\]' -e '\[CI RELEASE\]' | wc -c)
-#echo "count is: $filter_count"
-
-mkdir -p repo/
-cp server/build/Tachidesk-*.jar repo/
-cp server/build/Tachidesk-*.zip repo/
-
-ls repo
-pwd
-
-#if [ "$filter_count" -gt 0 ]; then
-#  cp server/build/Tachidesk-*.jar repo/
-#  cp server/build/Tachidesk-*.zip repo/
-#fi

.github/workflows/build_pull_request.yml

@@ -1,9 +1,6 @@
-name: CI
+name: CI Pull Request
 
 on:
-  push:
-    branches:
-      - master
   pull_request:
 
 jobs:
@@ -60,12 +57,12 @@ jobs:
             **/react/node_modules
           key: ${{ runner.os }}-${{ hashFiles('**/react/yarn.lock') }}
 
-      - name: Build Jar and launch4j
+      - name: Build and copy webUI, Build Jar and launch4j
         uses: eskatos/gradle-command-action@v1
         with:
           build-root-directory: master
           wrapper-directory: master
-          arguments: :server:windowsPackage --stacktrace
+          arguments: :webUI:copyBuild :server:windowsPackage --stacktrace
           wrapper-cache-enabled: true
           dependencies-cache-enabled: true
           configuration-cache-enabled: true

.github/workflows/build_push.yml

@@ -0,0 +1,80 @@
+name: CI build master
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  check_wrapper:
+    name: Validate Gradle Wrapper
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Clone repo
+        uses: actions/checkout@v2
+
+      - name: Validate Gradle Wrapper
+        uses: gradle/wrapper-validation-action@v1
+
+  build:
+    name: Build FatJar
+    needs: check_wrapper
+    if: "!startsWith(github.event.head_commit.message, '[SKIP CI]')"
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Cancel previous runs
+        uses: styfle/cancel-workflow-action@0.5.0
+        with:
+          access_token: ${{ github.token }}
+
+      - name: Checkout master branch
+        uses: actions/checkout@v2
+        with:
+          ref: master
+          path: master
+          fetch-depth: 0
+
+      - name: Set up JDK 1.8
+        uses: actions/setup-java@v1
+        with:
+          java-version: 1.8
+
+      - name: Copy CI gradle.properties
+        run: |
+          cd master
+          mkdir -p ~/.gradle
+          cp .github/runner-files/ci-gradle.properties ~/.gradle/gradle.properties
+
+      - name: Download android.jar
+        run: |
+          cd master
+          curl https://raw.githubusercontent.com/AriaMoradi/Tachidesk/android-jar/android.jar -o AndroidCompat/lib/android.jar
+
+      - name: Cache node_modules
+        uses: actions/cache@v2
+        with:
+          path: |
+            **/react/node_modules
+          key: ${{ runner.os }}-${{ hashFiles('**/react/yarn.lock') }}
+
+      - name: Build and copy webUI, Build Jar and launch4j
+        uses: eskatos/gradle-command-action@v1
+        with:
+          build-root-directory: master
+          wrapper-directory: master
+          arguments: :webUI:copyBuild :server:windowsPackage --stacktrace
+          wrapper-cache-enabled: true
+          dependencies-cache-enabled: true
+          configuration-cache-enabled: true
+
+      - name: Checkout preview branch
+        uses: actions/checkout@v2
+        with:
+          ref: preview
+          path: preview
+
+      - name: Deploy preview
+        run: |
+          ./master/.github/scripts/commit-repo.sh

.github/workflows/publish.yml

@@ -1,4 +1,4 @@
-name: Publish
+name: CI Publish
 
 on:
   push:
@@ -58,28 +58,22 @@ jobs:
             **/react/node_modules
           key: ${{ runner.os }}-${{ hashFiles('**/yarn.lock') }}
 
-      - name: Build Jar and launch4j
+      - name: Build and copy webUI, Build Jar and launch4j
         uses: eskatos/gradle-command-action@v1
         with:
           build-root-directory: master
           wrapper-directory: master
-          arguments: :server:windowsPackage --stacktrace
+          arguments: :webUI:copyBuild :server:windowsPackage --stacktrace
           wrapper-cache-enabled: true
           dependencies-cache-enabled: true
           configuration-cache-enabled: true
 
-
-      - name: Create repo artifacts
-        run: |
-          cd master
-          ./.github/scripts/create-repo.sh
-
       - name: Upload Release
         uses: xresloader/upload-to-github-release@master
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          file: "master/repo/*"
+          file: "master/server/build/*.jar;master/server/build/*-win32.zip"
           tags: true
           draft: true
           verbose: true

.gitignore

@@ -1,8 +1,11 @@
 # Ignore Gradle project-specific cache directory
 .gradle
 .idea
+gradle.properties
 
 # Ignore Gradle build output directory
 build
 
 server/src/main/resources/react
+server/tmp/
+server/tachiserver-data/

AndroidCompat/Config/src/main/java/xyz/nulldev/ts/config/ApplicationRootDir.kt

@@ -0,0 +1,18 @@
+package xyz.nulldev.ts.config
+
+import net.harawata.appdirs.AppDirsFactory
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+val ApplicationRootDir: String
+    get(): String {
+        return System.getProperty(
+                "ir.armor.tachidesk.rootDir",
+                AppDirsFactory.getInstance().getUserDataDir("Tachidesk", null, null)
+        )
+    }

AndroidCompat/Config/src/main/java/xyz/nulldev/ts/config/ConfigManager.kt

@@ -11,15 +11,12 @@ import com.typesafe.config.Config
 import com.typesafe.config.ConfigFactory
 import com.typesafe.config.ConfigRenderOptions
 import mu.KotlinLogging
-import net.harawata.appdirs.AppDirsFactory
 import java.io.File
 
 /**
  * Manages app config.
  */
 open class ConfigManager {
-    private val dataRoot by lazy { AppDirsFactory.getInstance().getUserDataDir("Tachidesk", null, null)!! }
-
     private val generatedModules = mutableMapOf<Class<out ConfigModule>, ConfigModule>()
     val config by lazy { loadConfigs() }
 
@@ -27,8 +24,6 @@ open class ConfigManager {
     val loadedModules: Map<Class<out ConfigModule>, ConfigModule>
         get() = generatedModules
 
-    open val appConfigFile: String = "$dataRoot/server.conf"
-
     val logger = KotlinLogging.logger {}
 
     /**
@@ -51,8 +46,8 @@ open class ConfigManager {
 
         //Load user config
         val userConfig =
-            File(appConfigFile).let{
-                    ConfigFactory.parseFile(it)
+            File(ApplicationRootDir, "server.conf").let {
+                ConfigFactory.parseFile(it)
             }
 
         val config = ConfigFactory.empty()
@@ -69,7 +64,7 @@ open class ConfigManager {
     }
 
     fun registerModule(module: ConfigModule) {
-        generatedModules.put(module.javaClass, module)
+        generatedModules[module.javaClass] = module
     }
 
     fun registerModules(vararg modules: ConfigModule) {

AndroidCompat/build.gradle.kts

@@ -30,23 +30,12 @@ dependencies {
     // Javassist
     compileOnly( "org.javassist:javassist:3.27.0-GA")
 
-    // Coroutines
-    val kotlinx_coroutines_version = "1.4.2"
-    compileOnly( "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlinx_coroutines_version")
-    compileOnly( "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:$kotlinx_coroutines_version")
-
     // XML
     compileOnly( group= "xmlpull", name= "xmlpull", version= "1.1.3.1")
 
     // Config API
     implementation(project(":AndroidCompat:Config"))
 
-    // dex2jar: https://github.com/DexPatcher/dex2jar/releases/tag/v2.1-20190905-lanchon
-    compileOnly("com.github.DexPatcher.dex2jar:dex-tools:v2.1-20190905-lanchon")
-
-    // APK parser
-    compileOnly("net.dongliu:apk-parser:2.6.10")
-
     // APK sig verifier
     compileOnly("com.android.tools.build:apksig:4.2.0-alpha13")
 

AndroidCompat/getAndroid.sh

@@ -8,6 +8,17 @@
 
 # This is a bash script to create android.jar stubs
 
+for dep in "curl" "base64" "zip"
+do
+  which $dep >/dev/null 2>&1 || { echo >&2 "Error: This script needs $dep installed."; abort=yes; }
+done
+
+if [ $abort = yes ]; then
+  echo "Some of the dependencies didn't exist. Aborting."
+  exit 1
+fi
+
+
 # foolproof against running from AndroidCompat dir instead of running from project root
 if [ "$(basename $(pwd))" = "AndroidCompat" ]; then
   cd ..

AndroidCompat/src/main/java/xyz/nulldev/androidcompat/pm/InstalledPackage.kt

@@ -22,7 +22,7 @@ data class InstalledPackage(val root: File) {
     val icon = File(root, "icon.png")
 
     val info: PackageInfo
-        get() = ApkParsers.getMetaInfo(apk).toPackageInfo(root, apk).also {
+        get() = ApkParsers.getMetaInfo(apk).toPackageInfo(apk).also {
             val parsed = ApkFile(apk)
             val dbFactory = DocumentBuilderFactory.newInstance()
             val dBuilder = dbFactory.newDocumentBuilder()
@@ -82,12 +82,14 @@ data class InstalledPackage(val root: File) {
         }
     }
 
-    private fun NodeList.toList(): List<Node> {
-        val out = mutableListOf<Node>()
+    companion object {
+        fun NodeList.toList(): List<Node> {
+            val out = mutableListOf<Node>()
 
-        for(i in 0 until length)
-            out += item(i)
+            for (i in 0 until length)
+                out += item(i)
 
-        return out
+            return out
+        }
     }
 }

AndroidCompat/src/main/java/xyz/nulldev/androidcompat/pm/PackageUtil.kt

@@ -6,7 +6,7 @@ import android.content.pm.PackageInfo
 import net.dongliu.apk.parser.bean.ApkMeta
 import java.io.File
 
-fun ApkMeta.toPackageInfo(root: File, apk: File): PackageInfo {
+fun ApkMeta.toPackageInfo(apk: File): PackageInfo {
     return PackageInfo().also {
         it.packageName = packageName
         it.versionCode = versionCode.toInt()

README.md

@@ -15,6 +15,7 @@ Here is a list of current features:
 - Searching and browsing installed sources.
 - A decent chapter reader.
 - Ability to download Mangas for offline read(This partially works)
+- Backup and restore support powered by Tachiyomi Legacy Backups
 
 **Note:** Keep in mind that Tachidesk is alpha software and can break rarely and/or with each update, so you may have to delete your data to fix it. See [General troubleshooting](#general-troubleshooting) and [Support and help](#support-and-help) if it happens.
 
@@ -24,9 +25,9 @@ Anyways, for more info checkout [finished milestone #1](https://github.com/Suway
 ### All Operating Systems
 You should have The Java Runtime Environment(JRE) 8 or newer and a modern browser installed. Also an internet connection is required as almost everything this app does is downloading stuff. 
 
-Download the latest jar release from [the releases section](https://github.com/Suwayomi/Tachidesk/releases).
+Download the latest "Stable" jar release from [the releases section](https://github.com/Suwayomi/Tachidesk/releases) or a preview jar build from [the preview branch](https://github.com/Suwayomi/Tachidesk/tree/preview).
 
-Double click on the jar file or run `java -jar Tachidesk-vX.Y.Z-rxxx.jar` from a Terminal/Command Prompt window to run the app which will open a new browser window automatically. Also the System Tray Icon is your friend if you need to open the browser window again or close Tachidesk.
+Double click on the jar file or run `java -jar Tachidesk-vX.Y.Z-rxxx.jar` (or `java -jar Tachidesk-latest.jar` if you have the latest preview) from a Terminal/Command Prompt window to run the app which will open a new browser window automatically. Also the System Tray Icon is your friend if you need to open the browser window again or close Tachidesk.
 
 ### Windows
 Download the latest win32 release from [the releases section](https://github.com/Suwayomi/Tachidesk/releases).
@@ -54,7 +55,7 @@ On Windows 7 and later : `C:\Users\<Account>\AppData\Local\Tachidesk`
 On Unix/Linux : `/home/<account>/.local/share/Tachidesk`
 
 ## Support and help
-Join Tachidesk's [discord server](https://discord.gg/wgPyb7hE5d) to hang out with the community and receive support and help.
+Join Tachidesk's [discord server](https://discord.gg/WdPS74cz) to hang out with the community and receive support and help.
 
 ## How does it work?
 This project has two components: 
@@ -65,7 +66,7 @@ This project has two components:
 ### Prerequisite: Get Android stubs jar
 #### Manual download
 Download [android.jar](https://raw.githubusercontent.com/Suwayomi/Tachidesk/android-jar/android.jar) and put it under `AndroidCompat/lib`.
-#### Automated download(needs `bash`, `curl`, `base64`, `zip` to work)
+#### Automated download
 Run `AndroidCompat/getAndroid.sh`(MacOS/Linux) or `AndroidCompat/getAndroid.ps1`(Windows) from project's root directory to download and rebuild the jar file from Google's repository.
 ### Prerequisite: Software dependencies
 You need this software packages installed in order to build this project:
@@ -73,18 +74,18 @@ You need this software packages installed in order to build this project:
 - Nodejs LTS or latest
 - Yarn
 ### building the full-blown jar
-Run `./gradlew server:shadowJar`, the resulting built jar file will be `server/build/Tachidesk-vX.Y.Z-rxxx.jar`.
-### building without `webUI` bundled
-Delete the `server/src/main/resources/react` directory if exists from previous runs, then run `./gradlew server:shadowJar -x :webUI:copyBuild`, the resulting built jar file will be `server/build/Tachidesk-vX.Y.Z-rxxx.jar`.
+Run `./gradlew :webUI:copyBuild server:shadowJar`, the resulting built jar file will be `server/build/Tachidesk-vX.Y.Z-rxxx.jar`.
+### building without `webUI` bundled(server only)
+Delete the `server/src/main/resources/react` directory if exists from previous runs, then run `./gradlew server:shadowJar`, the resulting built jar file will be `server/build/Tachidesk-vX.Y.Z-rxxx.jar`.
 ### building the Windows package
-Run `./gradlew windowsPackage`, the resulting built zip package file will be `server/build/Tachidesk-vX.Y.Z-rxxx-win32.zip`.
+Run `./gradlew :server:windowsPackage` to build a server only bundle and `./gradlew :webUI:copyBuild :server:windowsPackage` to get a full bundle , the resulting built zip package file will be `server/build/Tachidesk-vX.Y.Z-rxxx-win32.zip`.
 ## Running for development purposes
 ### `server` module
-Follow [Get Android stubs jar](#prerequisite-get-android-stubs-jar) then run `./gradlew :server:run -x :webUI:copyBuild --stacktrace` to run the server
+Follow [Get Android stubs jar](#prerequisite-get-android-stubs-jar) then run `./gradlew :server:run --stacktrace` to run the server
 ### `webUI` module
 How to do it is described in `webUI/react/README.md` but for short,
  first cd into `webUI/react` then run `yarn` to install the node modules(do this only once)
- then `yarn start` to start the client if a new browser window doesn't start automatically,
+ then `yarn start` to start the development server, if a new browser window doesn't get opned automatically,
  then open `http://127.0.0.1:3000` in a modern browser. This is a `create-react-app` project
  and supports HMR and all the other goodies you'll need.
 

build.gradle.kts

@@ -6,13 +6,14 @@ plugins {
 }
 
 allprojects {
-    group = "xyz.nulldev.ts"
+    group = "ir.armor.tachidesk"
 
     version = "1.0"
 
     repositories {
         jcenter()
         mavenCentral()
+        maven("https://maven.google.com/")
         maven("https://jitpack.io")
         maven("https://oss.sonatype.org/content/repositories/snapshots/")
         maven("https://dl.bintray.com/inorichi/maven")
@@ -20,13 +21,13 @@ allprojects {
     }
 }
 
-val javaProjects = listOf(
+val projects = listOf(
         project(":AndroidCompat"),
         project(":AndroidCompat:Config"),
         project(":server")
 )
 
-configure(javaProjects) {
+configure(projects) {
     apply(plugin = "java")
     apply(plugin = "org.jetbrains.kotlin.jvm")
 
@@ -45,17 +46,16 @@ configure(javaProjects) {
         // Kotlin
         implementation(kotlin("stdlib", KotlinCompilerVersion.VERSION))
         implementation(kotlin("stdlib", KotlinCompilerVersion.VERSION))
+        implementation(kotlin("reflect", version = "1.4.21"))
         testImplementation(kotlin("test", version = "1.4.21"))
-    }
-}
 
-configure(listOf(
-        project(":AndroidCompat"),
-        project(":server"),
-        project(":AndroidCompat:Config")
+        // coroutines
+        val coroutinesVersion = "1.4.2"
+        implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion")
+        implementation("org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:$coroutinesVersion")
+        implementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:$coroutinesVersion")
+
 
-)) {
-    dependencies {
         // Dependency Injection
         implementation("org.kodein.di:kodein-di-conf-jvm:7.1.0")
 
@@ -71,15 +71,18 @@ configure(listOf(
         // JSoup
         implementation("org.jsoup:jsoup:1.13.1")
 
-        // Kotlin
-        implementation(kotlin("reflect", version = "1.4.21"))
 
         // dependency of :AndroidCompat:Config
         implementation("com.typesafe:config:1.4.0")
         implementation("io.github.config4k:config4k:0.4.2")
 
-
         // to get application content root
         implementation("net.harawata:appdirs:1.2.0")
+
+        // dex2jar: https://github.com/DexPatcher/dex2jar/releases/tag/v2.1-20190905-lanchon
+        implementation("com.github.DexPatcher.dex2jar:dex-tools:v2.1-20190905-lanchon")
+
+        // APK parser
+        implementation("net.dongliu:apk-parser:2.6.10")
     }
 }

server/build.gradle.kts

@@ -9,7 +9,7 @@ plugins {
     id("edu.sc.seis.launch4j") version "2.4.9"
 }
 
-val TachideskVersion = "v0.2.7"
+val TachideskVersion = "v0.3.0"
 
 
 repositories {
@@ -30,19 +30,19 @@ dependencies {
 
     implementation("com.github.inorichi.injekt:injekt-core:65b0440")
 
-    val okhttp_version = "4.10.0-RC1"
-    implementation("com.squareup.okhttp3:okhttp:$okhttp_version")
-    implementation("com.squareup.okhttp3:logging-interceptor:$okhttp_version")
-    implementation("com.squareup.okhttp3:okhttp-dnsoverhttps:$okhttp_version")
+    val okhttpVersion = "4.10.0-RC1"
+    implementation("com.squareup.okhttp3:okhttp:$okhttpVersion")
+    implementation("com.squareup.okhttp3:logging-interceptor:$okhttpVersion")
+    implementation("com.squareup.okhttp3:okhttp-dnsoverhttps:$okhttpVersion")
     implementation("com.squareup.okio:okio:2.9.0")
 
 
     // retrofit
-    val retrofit_version = "2.9.0"
-    implementation("com.squareup.retrofit2:retrofit:$retrofit_version")
+    val retrofitVersion = "2.9.0"
+    implementation("com.squareup.retrofit2:retrofit:$retrofitVersion")
     implementation("com.jakewharton.retrofit:retrofit2-kotlinx-serialization-converter:0.8.0")
-    implementation("com.squareup.retrofit2:converter-gson:$retrofit_version")
-    implementation("com.squareup.retrofit2:adapter-rxjava:$retrofit_version")
+    implementation("com.squareup.retrofit2:converter-gson:$retrofitVersion")
+    implementation("com.squareup.retrofit2:adapter-rxjava:$retrofitVersion")
 
 
     // reactivex
@@ -59,22 +59,15 @@ dependencies {
     implementation("com.github.salomonbrys.kotson:kotson:2.5.0")
 
 
-    val coroutinesVersion = "1.3.9"
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion")
-
-    // dex2jar: https://github.com/DexPatcher/dex2jar/releases/tag/v2.1-20190905-lanchon
-    implementation("com.github.DexPatcher.dex2jar:dex-tools:v2.1-20190905-lanchon")
-
-
     // api
     implementation("io.javalin:javalin:3.12.0")
     implementation("com.fasterxml.jackson.core:jackson-databind:2.10.3")
 
     // Exposed ORM
-    val exposed_version = "0.28.1"
-    implementation("org.jetbrains.exposed:exposed-core:$exposed_version")
-    implementation("org.jetbrains.exposed:exposed-dao:$exposed_version")
-    implementation("org.jetbrains.exposed:exposed-jdbc:$exposed_version")
+    val exposedVersion = "0.28.1"
+    implementation("org.jetbrains.exposed:exposed-core:$exposedVersion")
+    implementation("org.jetbrains.exposed:exposed-dao:$exposedVersion")
+    implementation("org.jetbrains.exposed:exposed-jdbc:$exposedVersion")
     implementation("com.h2database:h2:1.4.199")
 
     // tray icon
@@ -87,6 +80,9 @@ dependencies {
 
     // uncomment to test extensions directly
 //    implementation(fileTree("lib/"))
+
+    // Testing
+    testImplementation(kotlin("test-junit5"))
 }
 
 val name = "ir.armor.tachidesk.Main"
@@ -135,6 +131,18 @@ tasks {
         archiveVersion.set(TachideskVersion)
         archiveClassifier.set(TachideskRevision)
     }
+    withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+        kotlinOptions {
+            freeCompilerArgs = listOf(
+                "-Xopt-in=kotlin.RequiresOptIn",
+                "-Xopt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
+                "-Xopt-in=kotlinx.coroutines.InternalCoroutinesApi"
+            )
+        }
+    }
+    test {
+        useJUnit()
+    }
 }
 
 launch4j { //used for windows
@@ -195,17 +203,17 @@ tasks.register<de.undercouch.gradle.tasks.download.Download>("downloadJre") {
 }
 
 tasks.withType<ShadowJar> {
-    destinationDir = File("$rootDir/server/build")
-    dependsOn("lintKotlin")
-}
-
-tasks.named("processResources") {
-    dependsOn(":webUI:copyBuild")
+    destinationDirectory.set(File("$rootDir/server/build"))
+    dependsOn("formatKotlin", "lintKotlin")
 }
 
 tasks.named("run") {
     dependsOn("formatKotlin", "lintKotlin")
 }
 
+tasks.named("processResources") {
+    mustRunAfter(":webUI:copyBuild")
+}
+
 
 

server/src/main/kotlin/eu/kanade/tachiyomi/extension/api/ExtensionGithubApi.kt

@@ -7,52 +7,17 @@ package eu.kanade.tachiyomi.extension.api
  * 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 android.content.Context
-// import eu.kanade.tachiyomi.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.extension.model.Extension
 import eu.kanade.tachiyomi.extension.util.ExtensionLoader
-import ir.armor.tachidesk.database.dataclass.ExtensionDataClass
-// import kotlinx.coroutines.Dispatchers
-// import kotlinx.coroutines.withContext
+import ir.armor.tachidesk.model.dataclass.ExtensionDataClass
 import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.int
 import kotlinx.serialization.json.jsonObject
 import kotlinx.serialization.json.jsonPrimitive
-// import uy.kohesive.injekt.injectLazy
 
-internal class ExtensionGithubApi {
-
-//    private val preferences: PreferencesHelper by injectLazy()
-
-    suspend fun findExtensions(): List<Extension.Available> {
-        val service: ExtensionGithubService = ExtensionGithubService.create()
-
-        val response = service.getRepo()
-        return parseResponse(response)
-    }
-
-//    suspend fun checkForUpdates(): List<Extension.Installed> {
-//        val extensions = fin   dExtensions()
-//
-// //        preferences.lastExtCheck().set(Date().time)
-//
-//        val installedExtensions = ExtensionLoader.loadExtensions(context)
-//            .filterIsInstance<LoadResult.Success>()
-//            .map { it.extension }
-//
-//        val extensionsWithUpdate = mutableListOf<Extension.Installed>()
-//        for (installedExt in installedExtensions) {
-//            val pkgName = installedExt.pkgName
-//            val availableExt = extensions.find { it.pkgName == pkgName } ?: continue
-//
-//            val hasUpdate = availableExt.versionCode > installedExt.versionCode
-//            if (hasUpdate) {
-//                extensionsWithUpdate.add(installedExt)
-//            }
-//        }
-//
-//        return extensionsWithUpdate
-//    }
+object ExtensionGithubApi {
+    const val BASE_URL = "https://raw.githubusercontent.com"
+    const val REPO_URL_PREFIX = "$BASE_URL/tachiyomiorg/tachiyomi-extensions/repo"
 
     private fun parseResponse(json: JsonArray): List<Extension.Available> {
         return json
@@ -75,16 +40,14 @@ internal class ExtensionGithubApi {
             }
     }
 
-    fun getApkUrl(extension: Extension.Available): String {
-        return "$REPO_URL_PREFIX/apk/${extension.apkName}"
+    suspend fun findExtensions(): List<Extension.Available> {
+        val service: ExtensionGithubService = ExtensionGithubService.create()
+
+        val response = service.getRepo()
+        return parseResponse(response)
     }
 
     fun getApkUrl(extension: ExtensionDataClass): String {
         return "$REPO_URL_PREFIX/apk/${extension.apkName}"
     }
-
-    companion object {
-        const val BASE_URL = "https://raw.githubusercontent.com/"
-        const val REPO_URL_PREFIX = "${BASE_URL}inorichi/tachiyomi-extensions/repo"
-    }
 }

server/src/main/kotlin/eu/kanade/tachiyomi/extension/api/ExtensionGithubService.kt

@@ -2,6 +2,7 @@ package eu.kanade.tachiyomi.extension.api
 
 import com.jakewharton.retrofit2.converter.kotlinx.serialization.asConverterFactory
 import eu.kanade.tachiyomi.network.NetworkHelper
+import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonArray
 import okhttp3.MediaType.Companion.toMediaType
@@ -9,8 +10,6 @@ import retrofit2.Retrofit
 import retrofit2.http.GET
 import uy.kohesive.injekt.injectLazy
 
-// import uy.kohesive.injekt.injectLazy
-
 /**
  * Used to get the extension repo listing from GitHub.
  */
@@ -30,6 +29,7 @@ interface ExtensionGithubService {
                 .build()
         }
 
+        @ExperimentalSerializationApi
         fun create(): ExtensionGithubService {
             val adapter = Retrofit.Builder()
                 .baseUrl(ExtensionGithubApi.BASE_URL)

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

@@ -0,0 +1,358 @@
+package eu.kanade.tachiyomi.source
+
+import android.content.Context
+import eu.kanade.tachiyomi.source.model.FilterList
+import eu.kanade.tachiyomi.source.model.MangasPage
+import eu.kanade.tachiyomi.source.model.Page
+import eu.kanade.tachiyomi.source.model.SChapter
+import eu.kanade.tachiyomi.source.model.SManga
+import rx.Observable
+
+// import com.github.junrar.Archive
+// import com.google.gson.JsonParser
+// import eu.kanade.tachiyomi.R
+// import eu.kanade.tachiyomi.source.model.Filter
+// import eu.kanade.tachiyomi.source.model.FilterList
+// import eu.kanade.tachiyomi.source.model.MangasPage
+// import eu.kanade.tachiyomi.source.model.Page
+// import eu.kanade.tachiyomi.source.model.SChapter
+// import eu.kanade.tachiyomi.source.model.SManga
+// import eu.kanade.tachiyomi.util.chapter.ChapterRecognition
+// import eu.kanade.tachiyomi.util.lang.compareToCaseInsensitiveNaturalOrder
+// import eu.kanade.tachiyomi.util.storage.DiskUtil
+// import eu.kanade.tachiyomi.util.storage.EpubFile
+// import eu.kanade.tachiyomi.util.system.ImageUtil
+// import rx.Observable
+// import timber.log.Timber
+// import java.io.File
+// import java.io.FileInputStream
+// import java.io.InputStream
+// import java.util.Locale
+// import java.util.concurrent.TimeUnit
+// import java.util.zip.ZipFile
+
+class LocalSource(private val context: Context) : CatalogueSource {
+    companion object {
+        const val ID = 0L
+//        const val HELP_URL = "https://tachiyomi.org/help/guides/reading-local-manga/"
+//
+//        private const val COVER_NAME = "cover.jpg"
+//        private val SUPPORTED_ARCHIVE_TYPES = setOf("zip", "rar", "cbr", "cbz", "epub")
+//
+//        private val POPULAR_FILTERS = FilterList(OrderBy())
+//        private val LATEST_FILTERS = FilterList(OrderBy().apply { state = Filter.Sort.Selection(1, false) })
+//        private val LATEST_THRESHOLD = TimeUnit.MILLISECONDS.convert(7, TimeUnit.DAYS)
+//
+//        fun updateCover(context: Context, manga: SManga, input: InputStream): File? {
+//            val dir = getBaseDirectories(context).firstOrNull()
+//            if (dir == null) {
+//                input.close()
+//                return null
+//            }
+//            val cover = File("${dir.absolutePath}/${manga.url}", COVER_NAME)
+//
+//            // It might not exist if using the external SD card
+//            cover.parentFile?.mkdirs()
+//            input.use {
+//                cover.outputStream().use {
+//                    input.copyTo(it)
+//                }
+//            }
+//            return cover
+//        }
+//
+//        private fun getBaseDirectories(context: Context): List<File> {
+//            val c = context.getString(R.string.app_name) + File.separator + "local"
+//            return DiskUtil.getExternalStorages(context).map { File(it.absolutePath, c) }
+//        }
+    }
+
+    override val id = ID
+    override val name = "Local source"
+    override val lang = ""
+    override val supportsLatest = true
+
+    override fun fetchMangaDetails(manga: SManga): Observable<SManga> {
+        TODO("Not yet implemented")
+    }
+
+    override fun fetchChapterList(manga: SManga): Observable<List<SChapter>> {
+        TODO("Not yet implemented")
+    }
+
+    override fun fetchPageList(chapter: SChapter): Observable<List<Page>> {
+        TODO("Not yet implemented")
+    }
+    override fun fetchPopularManga(page: Int): Observable<MangasPage> {
+        TODO("Not yet implemented")
+    }
+
+    override fun fetchSearchManga(page: Int, query: String, filters: FilterList): Observable<MangasPage> {
+        TODO("Not yet implemented")
+    }
+
+    override fun fetchLatestUpdates(page: Int): Observable<MangasPage> {
+        TODO("Not yet implemented")
+    }
+
+    override fun getFilterList(): FilterList {
+        TODO("Not yet implemented")
+    }
+//
+//    override fun toString() = context.getString(R.string.local_source)
+//
+//    override fun fetchPopularManga(page: Int) = fetchSearchManga(page, "", POPULAR_FILTERS)
+//
+//    override fun fetchSearchManga(page: Int, query: String, filters: FilterList): Observable<MangasPage> {
+//        val baseDirs = getBaseDirectories(context)
+//
+//        val time = if (filters === LATEST_FILTERS) System.currentTimeMillis() - LATEST_THRESHOLD else 0L
+//        var mangaDirs = baseDirs
+//            .asSequence()
+//            .mapNotNull { it.listFiles()?.toList() }
+//            .flatten()
+//            .filter { it.isDirectory }
+//            .filterNot { it.name.startsWith('.') }
+//            .filter { if (time == 0L) it.name.contains(query, ignoreCase = true) else it.lastModified() >= time }
+//            .distinctBy { it.name }
+//
+//        val state = ((if (filters.isEmpty()) POPULAR_FILTERS else filters)[0] as OrderBy).state
+//        when (state?.index) {
+//            0 -> {
+//                mangaDirs = if (state.ascending) {
+//                    mangaDirs.sortedBy { it.name.toLowerCase(Locale.ENGLISH) }
+//                } else {
+//                    mangaDirs.sortedByDescending { it.name.toLowerCase(Locale.ENGLISH) }
+//                }
+//            }
+//            1 -> {
+//                mangaDirs = if (state.ascending) {
+//                    mangaDirs.sortedBy(File::lastModified)
+//                } else {
+//                    mangaDirs.sortedByDescending(File::lastModified)
+//                }
+//            }
+//        }
+//
+//        val mangas = mangaDirs.map { mangaDir ->
+//            SManga.create().apply {
+//                title = mangaDir.name
+//                url = mangaDir.name
+//
+//                // Try to find the cover
+//                for (dir in baseDirs) {
+//                    val cover = File("${dir.absolutePath}/$url", COVER_NAME)
+//                    if (cover.exists()) {
+//                        thumbnail_url = cover.absolutePath
+//                        break
+//                    }
+//                }
+//
+//                val chapters = fetchChapterList(this).toBlocking().first()
+//                if (chapters.isNotEmpty()) {
+//                    val chapter = chapters.last()
+//                    val format = getFormat(chapter)
+//                    if (format is Format.Epub) {
+//                        EpubFile(format.file).use { epub ->
+//                            epub.fillMangaMetadata(this)
+//                        }
+//                    }
+//
+//                    // Copy the cover from the first chapter found.
+//                    if (thumbnail_url == null) {
+//                        try {
+//                            val dest = updateCover(chapter, this)
+//                            thumbnail_url = dest?.absolutePath
+//                        } catch (e: Exception) {
+//                            Timber.e(e)
+//                        }
+//                    }
+//                }
+//            }
+//        }
+//
+//        return Observable.just(MangasPage(mangas.toList(), false))
+//    }
+//
+//    override fun fetchLatestUpdates(page: Int) = fetchSearchManga(page, "", LATEST_FILTERS)
+//
+//    override fun fetchMangaDetails(manga: SManga): Observable<SManga> {
+//        getBaseDirectories(context)
+//            .asSequence()
+//            .mapNotNull { File(it, manga.url).listFiles()?.toList() }
+//            .flatten()
+//            .firstOrNull { it.extension == "json" }
+//            ?.apply {
+//                val reader = this.inputStream().bufferedReader()
+//                val json = JsonParser.parseReader(reader).asJsonObject
+//
+//                manga.title = json["title"]?.asString ?: manga.title
+//                manga.author = json["author"]?.asString ?: manga.author
+//                manga.artist = json["artist"]?.asString ?: manga.artist
+//                manga.description = json["description"]?.asString ?: manga.description
+//                manga.genre = json["genre"]?.asJsonArray?.joinToString(", ") { it.asString }
+//                    ?: manga.genre
+//                manga.status = json["status"]?.asInt ?: manga.status
+//            }
+//
+//        return Observable.just(manga)
+//    }
+//
+//    override fun fetchChapterList(manga: SManga): Observable<List<SChapter>> {
+//        val chapters = getBaseDirectories(context)
+//            .asSequence()
+//            .mapNotNull { File(it, manga.url).listFiles()?.toList() }
+//            .flatten()
+//            .filter { it.isDirectory || isSupportedFile(it.extension) }
+//            .map { chapterFile ->
+//                SChapter.create().apply {
+//                    url = "${manga.url}/${chapterFile.name}"
+//                    name = if (chapterFile.isDirectory) {
+//                        chapterFile.name
+//                    } else {
+//                        chapterFile.nameWithoutExtension
+//                    }
+//                    date_upload = chapterFile.lastModified()
+//
+//                    val format = getFormat(this)
+//                    if (format is Format.Epub) {
+//                        EpubFile(format.file).use { epub ->
+//                            epub.fillChapterMetadata(this)
+//                        }
+//                    }
+//
+//                    val chapNameCut = stripMangaTitle(name, manga.title)
+//                    if (chapNameCut.isNotEmpty()) name = chapNameCut
+//                    ChapterRecognition.parseChapterNumber(this, manga)
+//                }
+//            }
+//            .sortedWith(
+//                Comparator { c1, c2 ->
+//                    val c = c2.chapter_number.compareTo(c1.chapter_number)
+//                    if (c == 0) c2.name.compareToCaseInsensitiveNaturalOrder(c1.name) else c
+//                }
+//            )
+//            .toList()
+//
+//        return Observable.just(chapters)
+//    }
+//
+//    /**
+//     * Strips the manga title from a chapter name, matching only based on alphanumeric and whitespace
+//     * characters.
+//     */
+//    private fun stripMangaTitle(chapterName: String, mangaTitle: String): String {
+//        var chapterNameIndex = 0
+//        var mangaTitleIndex = 0
+//        while (chapterNameIndex < chapterName.length && mangaTitleIndex < mangaTitle.length) {
+//            val chapterChar = chapterName[chapterNameIndex]
+//            val mangaChar = mangaTitle[mangaTitleIndex]
+//            if (!chapterChar.equals(mangaChar, true)) {
+//                val invalidChapterChar = !chapterChar.isLetterOrDigit() && !chapterChar.isWhitespace()
+//                val invalidMangaChar = !mangaChar.isLetterOrDigit() && !mangaChar.isWhitespace()
+//
+//                if (!invalidChapterChar && !invalidMangaChar) {
+//                    return chapterName
+//                }
+//
+//                if (invalidChapterChar) {
+//                    chapterNameIndex++
+//                }
+//
+//                if (invalidMangaChar) {
+//                    mangaTitleIndex++
+//                }
+//            } else {
+//                chapterNameIndex++
+//                mangaTitleIndex++
+//            }
+//        }
+//
+//        return chapterName.substring(chapterNameIndex).trimStart(' ', '-', '_', ',', ':')
+//    }
+//
+//    override fun fetchPageList(chapter: SChapter): Observable<List<Page>> {
+//        return Observable.error(Exception("Unused"))
+//    }
+//
+//    private fun isSupportedFile(extension: String): Boolean {
+//        return extension.toLowerCase() in SUPPORTED_ARCHIVE_TYPES
+//    }
+//
+//    fun getFormat(chapter: SChapter): Format {
+//        val baseDirs = getBaseDirectories(context)
+//
+//        for (dir in baseDirs) {
+//            val chapFile = File(dir, chapter.url)
+//            if (!chapFile.exists()) continue
+//
+//            return getFormat(chapFile)
+//        }
+//        throw Exception("Chapter not found")
+//    }
+//
+//    private fun getFormat(file: File): Format {
+//        val extension = file.extension
+//        return if (file.isDirectory) {
+//            Format.Directory(file)
+//        } else if (extension.equals("zip", true) || extension.equals("cbz", true)) {
+//            Format.Zip(file)
+//        } else if (extension.equals("rar", true) || extension.equals("cbr", true)) {
+//            Format.Rar(file)
+//        } else if (extension.equals("epub", true)) {
+//            Format.Epub(file)
+//        } else {
+//            throw Exception("Invalid chapter format")
+//        }
+//    }
+//
+//    private fun updateCover(chapter: SChapter, manga: SManga): File? {
+//        return when (val format = getFormat(chapter)) {
+//            is Format.Directory -> {
+//                val entry = format.file.listFiles()
+//                    ?.sortedWith { f1, f2 -> f1.name.compareToCaseInsensitiveNaturalOrder(f2.name) }
+//                    ?.find { !it.isDirectory && ImageUtil.isImage(it.name) { FileInputStream(it) } }
+//
+//                entry?.let { updateCover(context, manga, it.inputStream()) }
+//            }
+//            is Format.Zip -> {
+//                ZipFile(format.file).use { zip ->
+//                    val entry = zip.entries().toList()
+//                        .sortedWith { f1, f2 -> f1.name.compareToCaseInsensitiveNaturalOrder(f2.name) }
+//                        .find { !it.isDirectory && ImageUtil.isImage(it.name) { zip.getInputStream(it) } }
+//
+//                    entry?.let { updateCover(context, manga, zip.getInputStream(it)) }
+//                }
+//            }
+//            is Format.Rar -> {
+//                Archive(format.file).use { archive ->
+//                    val entry = archive.fileHeaders
+//                        .sortedWith { f1, f2 -> f1.fileName.compareToCaseInsensitiveNaturalOrder(f2.fileName) }
+//                        .find { !it.isDirectory && ImageUtil.isImage(it.fileName) { archive.getInputStream(it) } }
+//
+//                    entry?.let { updateCover(context, manga, archive.getInputStream(it)) }
+//                }
+//            }
+//            is Format.Epub -> {
+//                EpubFile(format.file).use { epub ->
+//                    val entry = epub.getImagesFromPages()
+//                        .firstOrNull()
+//                        ?.let { epub.getEntry(it) }
+//
+//                    entry?.let { updateCover(context, manga, epub.getInputStream(it)) }
+//                }
+//            }
+//        }
+//    }
+//
+//    private class OrderBy : Filter.Sort("Order by", arrayOf("Title", "Date"), Selection(0, true))
+//
+//    override fun getFilterList() = FilterList(OrderBy())
+//
+//    sealed class Format {
+//        data class Directory(val file: File) : Format()
+//        data class Zip(val file: File) : Format()
+//        data class Rar(val file: File) : Format()
+//        data class Epub(val file: File) : Format()
+//    }
+}

server/src/main/kotlin/eu/kanade/tachiyomi/util/lang/Hash.kt

@@ -0,0 +1,44 @@
+package eu.kanade.tachiyomi.util.lang
+
+import java.security.MessageDigest
+
+object Hash {
+
+    private val chars = charArrayOf(
+        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+        'a', 'b', 'c', 'd', 'e', 'f'
+    )
+
+    private val MD5 get() = MessageDigest.getInstance("MD5")
+
+    private val SHA256 get() = MessageDigest.getInstance("SHA-256")
+
+    fun sha256(bytes: ByteArray): String {
+        return encodeHex(SHA256.digest(bytes))
+    }
+
+    fun sha256(string: String): String {
+        return sha256(string.toByteArray())
+    }
+
+    fun md5(bytes: ByteArray): String {
+        return encodeHex(MD5.digest(bytes))
+    }
+
+    fun md5(string: String): String {
+        return md5(string.toByteArray())
+    }
+
+    private fun encodeHex(data: ByteArray): String {
+        val l = data.size
+        val out = CharArray(l shl 1)
+        var i = 0
+        var j = 0
+        while (i < l) {
+            out[j++] = chars[(240 and data[i].toInt()).ushr(4)]
+            out[j++] = chars[15 and data[i].toInt()]
+            i++
+        }
+        return String(out)
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/Main.kt

@@ -7,8 +7,8 @@ package ir.armor.tachidesk
  * 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 ir.armor.tachidesk.server.JavalinSetup.javalinSetup
 import ir.armor.tachidesk.server.applicationSetup
-import ir.armor.tachidesk.server.javalinSetup
 
 class Main {
     companion object {

server/src/main/kotlin/ir/armor/tachidesk/database/entity/ExtensionEntity.kt

@@ -1,28 +0,0 @@
-package ir.armor.tachidesk.database.entity
-
-/*
- * Copyright (C) Contributors to the Suwayomi project
- * 
- * This Source Code Form is subject to the terms of the Mozilla Public
- * 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 ir.armor.tachidesk.database.table.ExtensionTable
-import org.jetbrains.exposed.dao.IntEntity
-import org.jetbrains.exposed.dao.IntEntityClass
-import org.jetbrains.exposed.dao.id.EntityID
-
-class ExtensionEntity(id: EntityID<Int>) : IntEntity(id) {
-    companion object : IntEntityClass<ExtensionEntity>(ExtensionTable)
-
-    var name by ExtensionTable.name
-    var pkgName by ExtensionTable.pkgName
-    var versionName by ExtensionTable.versionName
-    var versionCode by ExtensionTable.versionCode
-    var lang by ExtensionTable.lang
-    var isNsfw by ExtensionTable.isNsfw
-    var apkName by ExtensionTable.apkName
-    var iconUrl by ExtensionTable.iconUrl
-    var installed by ExtensionTable.installed
-    var classFQName by ExtensionTable.classFQName
-}

server/src/main/kotlin/ir/armor/tachidesk/database/entity/MangaEntity.kt

@@ -1,30 +0,0 @@
-package ir.armor.tachidesk.database.entity
-
-/*
- * Copyright (C) Contributors to the Suwayomi project
- * 
- * This Source Code Form is subject to the terms of the Mozilla Public
- * 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 ir.armor.tachidesk.database.table.MangaTable
-import org.jetbrains.exposed.dao.IntEntity
-import org.jetbrains.exposed.dao.IntEntityClass
-import org.jetbrains.exposed.dao.id.EntityID
-
-class MangaEntity(id: EntityID<Int>) : IntEntity(id) {
-    companion object : IntEntityClass<MangaEntity>(MangaTable)
-
-    var url by MangaTable.url
-    var title by MangaTable.title
-    var initialized by MangaTable.initialized
-
-    var artist by MangaTable.artist
-    var author by MangaTable.author
-    var description by MangaTable.description
-    var genre by MangaTable.genre
-    var status by MangaTable.status
-    var thumbnail_url by MangaTable.thumbnail_url
-
-    var sourceReference by MangaEntity referencedOn MangaTable.sourceReference
-}

server/src/main/kotlin/ir/armor/tachidesk/database/entity/SourceEntity.kt

@@ -1,24 +0,0 @@
-package ir.armor.tachidesk.database.entity
-
-/*
- * Copyright (C) Contributors to the Suwayomi project
- * 
- * This Source Code Form is subject to the terms of the Mozilla Public
- * 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 ir.armor.tachidesk.database.table.SourceTable
-import org.jetbrains.exposed.dao.EntityClass
-import org.jetbrains.exposed.dao.LongEntity
-import org.jetbrains.exposed.dao.id.EntityID
-
-class SourceEntity(id: EntityID<Long>) : LongEntity(id) {
-    companion object : EntityClass<Long, SourceEntity>(SourceTable, null)
-
-    var sourceId by SourceTable.id
-    var name by SourceTable.name
-    var lang by SourceTable.lang
-    var extension by ExtensionEntity referencedOn SourceTable.extension
-    var partOfFactorySource by SourceTable.partOfFactorySource
-    var positionInFactorySource by SourceTable.positionInFactorySource
-}

server/src/main/kotlin/ir/armor/tachidesk/impl/Category.kt

@@ -7,10 +7,11 @@ package ir.armor.tachidesk.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 ir.armor.tachidesk.database.dataclass.CategoryDataClass
-import ir.armor.tachidesk.database.table.CategoryMangaTable
-import ir.armor.tachidesk.database.table.CategoryTable
-import ir.armor.tachidesk.database.table.toDataClass
+import ir.armor.tachidesk.impl.CategoryManga.removeMangaFromCategory
+import ir.armor.tachidesk.model.database.CategoryMangaTable
+import ir.armor.tachidesk.model.database.CategoryTable
+import ir.armor.tachidesk.model.database.toDataClass
+import ir.armor.tachidesk.model.dataclass.CategoryDataClass
 import org.jetbrains.exposed.sql.SortOrder
 import org.jetbrains.exposed.sql.deleteWhere
 import org.jetbrains.exposed.sql.insert
@@ -19,51 +20,59 @@ import org.jetbrains.exposed.sql.selectAll
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
 
-fun createCategory(name: String) {
-    transaction {
-        val count = CategoryTable.selectAll().count()
-        if (CategoryTable.select { CategoryTable.name eq name }.firstOrNull() == null)
-            CategoryTable.insert {
-                it[CategoryTable.name] = name
-                it[CategoryTable.order] = count.toInt() + 1
-            }
-    }
-}
-
-fun updateCategory(categoryId: Int, name: String?, isLanding: Boolean?) {
-    transaction {
-        CategoryTable.update({ CategoryTable.id eq categoryId }) {
-            if (name != null) it[CategoryTable.name] = name
-            if (isLanding != null) it[CategoryTable.isLanding] = isLanding
+object Category {
+    /**
+     * The new category will be placed at the end of the list
+     */
+    fun createCategory(name: String) {
+        transaction {
+            val count = CategoryTable.selectAll().count()
+            if (CategoryTable.select { CategoryTable.name eq name }.firstOrNull() == null)
+                CategoryTable.insert {
+                    it[CategoryTable.name] = name
+                    it[CategoryTable.order] = count.toInt() + 1
+                }
         }
     }
-}
 
-fun reorderCategory(categoryId: Int, from: Int, to: Int) {
-    transaction {
-        val categories = CategoryTable.selectAll().orderBy(CategoryTable.order to SortOrder.ASC).toMutableList()
-        categories.add(to - 1, categories.removeAt(from - 1))
-        categories.forEachIndexed { index, cat ->
-            CategoryTable.update({ CategoryTable.id eq cat[CategoryTable.id].value }) {
-                it[CategoryTable.order] = index + 1
+    fun updateCategory(categoryId: Int, name: String?, isLanding: Boolean?) {
+        transaction {
+            CategoryTable.update({ CategoryTable.id eq categoryId }) {
+                if (name != null) it[CategoryTable.name] = name
+                if (isLanding != null) it[CategoryTable.isLanding] = isLanding
+            }
+        }
+    }
+
+/**
+     * Move the category from position `from` to `to`
+     */
+    fun reorderCategory(categoryId: Int, from: Int, to: Int) {
+        transaction {
+            val categories = CategoryTable.selectAll().orderBy(CategoryTable.order to SortOrder.ASC).toMutableList()
+            categories.add(to - 1, categories.removeAt(from - 1))
+            categories.forEachIndexed { index, cat ->
+                CategoryTable.update({ CategoryTable.id eq cat[CategoryTable.id].value }) {
+                    it[CategoryTable.order] = index + 1
+                }
+            }
+        }
+    }
+
+    fun removeCategory(categoryId: Int) {
+        transaction {
+            CategoryMangaTable.select { CategoryMangaTable.category eq categoryId }.forEach {
+                removeMangaFromCategory(it[CategoryMangaTable.manga].value, categoryId)
+            }
+            CategoryTable.deleteWhere { CategoryTable.id eq categoryId }
+        }
+    }
+
+    fun getCategoryList(): List<CategoryDataClass> {
+        return transaction {
+            CategoryTable.selectAll().orderBy(CategoryTable.order to SortOrder.ASC).map {
+                CategoryTable.toDataClass(it)
             }
         }
     }
 }
-
-fun removeCategory(categoryId: Int) {
-    transaction {
-        CategoryMangaTable.select { CategoryMangaTable.category eq categoryId }.forEach {
-            removeMangaFromCategory(it[CategoryMangaTable.manga].value, categoryId)
-        }
-        CategoryTable.deleteWhere { CategoryTable.id eq categoryId }
-    }
-}
-
-fun getCategoryList(): List<CategoryDataClass> {
-    return transaction {
-        CategoryTable.selectAll().orderBy(CategoryTable.order to SortOrder.ASC).map {
-            CategoryTable.toDataClass(it)
-        }
-    }
-}

server/src/main/kotlin/ir/armor/tachidesk/impl/CategoryManga.kt

@@ -7,12 +7,12 @@ package ir.armor.tachidesk.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 ir.armor.tachidesk.database.dataclass.CategoryDataClass
-import ir.armor.tachidesk.database.dataclass.MangaDataClass
-import ir.armor.tachidesk.database.table.CategoryMangaTable
-import ir.armor.tachidesk.database.table.CategoryTable
-import ir.armor.tachidesk.database.table.MangaTable
-import ir.armor.tachidesk.database.table.toDataClass
+import ir.armor.tachidesk.model.database.CategoryMangaTable
+import ir.armor.tachidesk.model.database.CategoryTable
+import ir.armor.tachidesk.model.database.MangaTable
+import ir.armor.tachidesk.model.database.toDataClass
+import ir.armor.tachidesk.model.dataclass.CategoryDataClass
+import ir.armor.tachidesk.model.dataclass.MangaDataClass
 import org.jetbrains.exposed.sql.SortOrder
 import org.jetbrains.exposed.sql.and
 import org.jetbrains.exposed.sql.deleteWhere
@@ -21,44 +21,52 @@ import org.jetbrains.exposed.sql.select
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
 
-fun addMangaToCategory(mangaId: Int, categoryId: Int) {
-    transaction {
-        if (CategoryMangaTable.select { (CategoryMangaTable.category eq categoryId) and (CategoryMangaTable.manga eq mangaId) }.firstOrNull() == null) {
-            CategoryMangaTable.insert {
-                it[CategoryMangaTable.category] = categoryId
-                it[CategoryMangaTable.manga] = mangaId
-            }
+object CategoryManga {
+    fun addMangaToCategory(mangaId: Int, categoryId: Int) {
+        transaction {
+            if (CategoryMangaTable.select { (CategoryMangaTable.category eq categoryId) and (CategoryMangaTable.manga eq mangaId) }.firstOrNull() == null) {
+                CategoryMangaTable.insert {
+                    it[CategoryMangaTable.category] = categoryId
+                    it[CategoryMangaTable.manga] = mangaId
+                }
 
-            MangaTable.update({ MangaTable.id eq mangaId }) {
-                it[MangaTable.defaultCategory] = false
+                MangaTable.update({ MangaTable.id eq mangaId }) {
+                    it[MangaTable.defaultCategory] = false
+                }
+            }
+        }
+    }
+
+    fun removeMangaFromCategory(mangaId: Int, categoryId: Int) {
+        transaction {
+            CategoryMangaTable.deleteWhere { (CategoryMangaTable.category eq categoryId) and (CategoryMangaTable.manga eq mangaId) }
+            if (CategoryMangaTable.select { CategoryMangaTable.manga eq mangaId }.count() == 0L) {
+                MangaTable.update({ MangaTable.id eq mangaId }) {
+                    it[MangaTable.defaultCategory] = true
+                }
+            }
+        }
+    }
+
+    /**
+     * list of mangas that belong to a category
+     */
+    fun getCategoryMangaList(categoryId: Int): List<MangaDataClass> {
+        return transaction {
+            CategoryMangaTable.innerJoin(MangaTable).select { CategoryMangaTable.category eq categoryId }.map {
+                MangaTable.toDataClass(it)
+            }
+        }
+    }
+
+    /**
+     * list of categories that a manga belongs to
+     */
+    fun getMangaCategories(mangaId: Int): List<CategoryDataClass> {
+        return transaction {
+            CategoryMangaTable.innerJoin(CategoryTable).select { CategoryMangaTable.manga eq mangaId }.orderBy(CategoryTable.order to SortOrder.ASC).map {
+                CategoryTable.toDataClass(it)
             }
         }
     }
 }
-
-fun removeMangaFromCategory(mangaId: Int, categoryId: Int) {
-    transaction {
-        CategoryMangaTable.deleteWhere { (CategoryMangaTable.category eq categoryId) and (CategoryMangaTable.manga eq mangaId) }
-        if (CategoryMangaTable.select { CategoryMangaTable.manga eq mangaId }.count() == 0L) {
-            MangaTable.update({ MangaTable.id eq mangaId }) {
-                it[MangaTable.defaultCategory] = true
-            }
-        }
-    }
-}
-
-fun getCategoryMangaList(categoryId: Int): List<MangaDataClass> {
-    return transaction {
-        CategoryMangaTable.innerJoin(MangaTable).select { CategoryMangaTable.category eq categoryId }.map {
-            MangaTable.toDataClass(it)
-        }
-    }
-}
-
-fun getMangaCategories(mangaId: Int): List<CategoryDataClass> {
-    return transaction {
-        CategoryMangaTable.innerJoin(CategoryTable).select { CategoryMangaTable.manga eq mangaId }.orderBy(CategoryTable.order to SortOrder.ASC).map {
-            CategoryTable.toDataClass(it)
-        }
-    }
-}

server/src/main/kotlin/ir/armor/tachidesk/impl/Chapter.kt

@@ -9,86 +9,90 @@ package ir.armor.tachidesk.impl
 
 import eu.kanade.tachiyomi.source.model.SChapter
 import eu.kanade.tachiyomi.source.model.SManga
-import ir.armor.tachidesk.database.dataclass.ChapterDataClass
-import ir.armor.tachidesk.database.table.ChapterTable
-import ir.armor.tachidesk.database.table.MangaTable
-import ir.armor.tachidesk.database.table.PageTable
+import ir.armor.tachidesk.impl.Manga.getManga
+import ir.armor.tachidesk.impl.util.GetHttpSource.getHttpSource
+import ir.armor.tachidesk.impl.util.awaitSingle
+import ir.armor.tachidesk.model.database.ChapterTable
+import ir.armor.tachidesk.model.database.MangaTable
+import ir.armor.tachidesk.model.database.PageTable
+import ir.armor.tachidesk.model.dataclass.ChapterDataClass
 import org.jetbrains.exposed.sql.and
 import org.jetbrains.exposed.sql.insert
-import org.jetbrains.exposed.sql.insertAndGetId
 import org.jetbrains.exposed.sql.select
 import org.jetbrains.exposed.sql.selectAll
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
 
-fun getChapterList(mangaId: Int): List<ChapterDataClass> {
-    val mangaDetails = getManga(mangaId)
-    val source = getHttpSource(mangaDetails.sourceId.toLong())
+object Chapter {
+    /** get chapter list when showing a manga */
+    suspend fun getChapterList(mangaId: Int): List<ChapterDataClass> {
+        val mangaDetails = getManga(mangaId)
+        val source = getHttpSource(mangaDetails.sourceId.toLong())
 
-    val chapterList = source.fetchChapterList(
-        SManga.create().apply {
-            title = mangaDetails.title
-            url = mangaDetails.url
-        }
-    ).toBlocking().first()
+        val chapterList = source.fetchChapterList(
+            SManga.create().apply {
+                title = mangaDetails.title
+                url = mangaDetails.url
+            }
+        ).awaitSingle()
 
-    val chapterCount = chapterList.count()
+        val chapterCount = chapterList.count()
 
-    return transaction {
-        chapterList.reversed().forEachIndexed { index, fetchedChapter ->
-            val chapterEntry = ChapterTable.select { ChapterTable.url eq fetchedChapter.url }.firstOrNull()
-            if (chapterEntry == null) {
-                ChapterTable.insertAndGetId {
-                    it[url] = fetchedChapter.url
-                    it[name] = fetchedChapter.name
-                    it[date_upload] = fetchedChapter.date_upload
-                    it[chapter_number] = fetchedChapter.chapter_number
-                    it[scanlator] = fetchedChapter.scanlator
+        return transaction {
+            chapterList.reversed().forEachIndexed { index, fetchedChapter ->
+                val chapterEntry = ChapterTable.select { ChapterTable.url eq fetchedChapter.url }.firstOrNull()
+                if (chapterEntry == null) {
+                    ChapterTable.insert {
+                        it[url] = fetchedChapter.url
+                        it[name] = fetchedChapter.name
+                        it[date_upload] = fetchedChapter.date_upload
+                        it[chapter_number] = fetchedChapter.chapter_number
+                        it[scanlator] = fetchedChapter.scanlator
 
-                    it[chapterIndex] = index + 1
-                    it[manga] = mangaId
-                }
-            } else {
-                ChapterTable.update({ ChapterTable.url eq fetchedChapter.url }) {
-                    it[name] = fetchedChapter.name
-                    it[date_upload] = fetchedChapter.date_upload
-                    it[chapter_number] = fetchedChapter.chapter_number
-                    it[scanlator] = fetchedChapter.scanlator
+                        it[chapterIndex] = index + 1
+                        it[manga] = mangaId
+                    }
+                } else {
+                    ChapterTable.update({ ChapterTable.url eq fetchedChapter.url }) {
+                        it[name] = fetchedChapter.name
+                        it[date_upload] = fetchedChapter.date_upload
+                        it[chapter_number] = fetchedChapter.chapter_number
+                        it[scanlator] = fetchedChapter.scanlator
 
-                    it[chapterIndex] = index + 1
-                    it[manga] = mangaId
+                        it[chapterIndex] = index + 1
+                        it[manga] = mangaId
+                    }
                 }
             }
-        }
 
-        // clear any orphaned chapters
-        val dbChapterCount = transaction { ChapterTable.selectAll().count() }
-        if (dbChapterCount > chapterCount) { // we got some clean up due
-            // TODO
-        }
+            // clear any orphaned chapters that are in the db but not in `chapterList`
+            val dbChapterCount = transaction { ChapterTable.selectAll().count() }
+            if (dbChapterCount > chapterCount) { // we got some clean up due
+                // TODO: delete orphan chapters
+            }
 
-        return@transaction chapterList.mapIndexed { index, it ->
-            ChapterDataClass(
-                ChapterTable.select { ChapterTable.url eq it.url }.firstOrNull()!![ChapterTable.id].value,
-                it.url,
-                it.name,
-                it.date_upload,
-                it.chapter_number,
-                it.scanlator,
-                mangaId,
-                chapterCount - index,
-                chapterCount
-            )
+            chapterList.mapIndexed { index, it ->
+                ChapterDataClass(
+                    it.url,
+                    it.name,
+                    it.date_upload,
+                    it.chapter_number,
+                    it.scanlator,
+                    mangaId,
+                    chapterCount - index,
+                )
+            }
         }
     }
-}
 
-fun getChapter(chapterIndex: Int, mangaId: Int): ChapterDataClass {
-    return transaction {
-        val chapterEntry = ChapterTable.select {
-            ChapterTable.chapterIndex eq chapterIndex and (ChapterTable.manga eq mangaId)
-        }.firstOrNull()!!
-        val mangaEntry = MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!!
+    /** used to display a chapter, get a chapter in order to show it's pages */
+    suspend fun getChapter(chapterIndex: Int, mangaId: Int): ChapterDataClass {
+        val chapterEntry = transaction {
+            ChapterTable.select {
+                (ChapterTable.chapterIndex eq chapterIndex) and (ChapterTable.manga eq mangaId)
+            }.firstOrNull()!!
+        }
+        val mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
         val source = getHttpSource(mangaEntry[MangaTable.sourceReference])
 
         val pageList = source.fetchPageList(
@@ -96,38 +100,23 @@ fun getChapter(chapterIndex: Int, mangaId: Int): ChapterDataClass {
                 url = chapterEntry[ChapterTable.url]
                 name = chapterEntry[ChapterTable.name]
             }
-        ).toBlocking().first()
+        ).awaitSingle()
 
         val chapterId = chapterEntry[ChapterTable.id].value
         val chapterCount = transaction { ChapterTable.selectAll().count() }
 
-        val chapter = ChapterDataClass(
-            chapterId,
-            chapterEntry[ChapterTable.url],
-            chapterEntry[ChapterTable.name],
-            chapterEntry[ChapterTable.date_upload],
-            chapterEntry[ChapterTable.chapter_number],
-            chapterEntry[ChapterTable.scanlator],
-            mangaId,
-            chapterEntry[ChapterTable.chapterIndex],
-            chapterCount.toInt(),
-
-            pageList.count()
-        )
-
-        pageList.forEach { page ->
-            val pageEntry = transaction { PageTable.select { (PageTable.chapter eq chapterId) and (PageTable.index eq page.index) }.firstOrNull() }
-            if (pageEntry == null) {
-                transaction {
+        // update page list for this chapter
+        transaction {
+            pageList.forEach { page ->
+                val pageEntry = transaction { PageTable.select { (PageTable.chapter eq chapterId) and (PageTable.index eq page.index) }.firstOrNull() }
+                if (pageEntry == null) {
                     PageTable.insert {
                         it[index] = page.index
                         it[url] = page.url
                         it[imageUrl] = page.imageUrl
-                        it[this.chapter] = chapterId
+                        it[chapter] = chapterId
                     }
-                }
-            } else {
-                transaction {
+                } else {
                     PageTable.update({ (PageTable.chapter eq chapterId) and (PageTable.index eq page.index) }) {
                         it[url] = page.url
                         it[imageUrl] = page.imageUrl
@@ -136,6 +125,16 @@ fun getChapter(chapterIndex: Int, mangaId: Int): ChapterDataClass {
             }
         }
 
-        return@transaction chapter
+        return ChapterDataClass(
+            chapterEntry[ChapterTable.url],
+            chapterEntry[ChapterTable.name],
+            chapterEntry[ChapterTable.date_upload],
+            chapterEntry[ChapterTable.chapter_number],
+            chapterEntry[ChapterTable.scanlator],
+            mangaId,
+            chapterEntry[ChapterTable.chapterIndex],
+            chapterCount.toInt(),
+            pageList.count()
+        )
     }
 }

server/src/main/kotlin/ir/armor/tachidesk/impl/Extension.kt

@@ -7,19 +7,29 @@ package ir.armor.tachidesk.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 com.googlecode.d2j.dex.Dex2jar
-import com.googlecode.d2j.reader.MultiDexFileReader
-import com.googlecode.dex2jar.tools.BaksmaliBaseDexExceptionHandler
+import android.net.Uri
 import eu.kanade.tachiyomi.extension.api.ExtensionGithubApi
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.network.NetworkHelper
+import eu.kanade.tachiyomi.source.CatalogueSource
+import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.source.SourceFactory
-import eu.kanade.tachiyomi.source.online.HttpSource
-import ir.armor.tachidesk.database.table.ExtensionTable
-import ir.armor.tachidesk.database.table.SourceTable
-import ir.armor.tachidesk.impl.util.APKExtractor
-import ir.armor.tachidesk.server.applicationDirs
-import kotlinx.coroutines.runBlocking
+import ir.armor.tachidesk.impl.ExtensionsList.extensionTableAsDataClass
+import ir.armor.tachidesk.impl.util.CachedImageResponse.getCachedImageResponse
+import ir.armor.tachidesk.impl.util.PackageTools.EXTENSION_FEATURE
+import ir.armor.tachidesk.impl.util.PackageTools.LIB_VERSION_MAX
+import ir.armor.tachidesk.impl.util.PackageTools.LIB_VERSION_MIN
+import ir.armor.tachidesk.impl.util.PackageTools.METADATA_NSFW
+import ir.armor.tachidesk.impl.util.PackageTools.METADATA_SOURCE_CLASS
+import ir.armor.tachidesk.impl.util.PackageTools.dex2jar
+import ir.armor.tachidesk.impl.util.PackageTools.getPackageInfo
+import ir.armor.tachidesk.impl.util.PackageTools.getSignatureHash
+import ir.armor.tachidesk.impl.util.PackageTools.loadExtensionSources
+import ir.armor.tachidesk.impl.util.PackageTools.trustedSignatures
+import ir.armor.tachidesk.impl.util.await
+import ir.armor.tachidesk.model.database.ExtensionTable
+import ir.armor.tachidesk.model.database.SourceTable
+import ir.armor.tachidesk.server.ApplicationDirs
 import mu.KotlinLogging
 import okhttp3.Request
 import okio.buffer
@@ -29,179 +39,213 @@ import org.jetbrains.exposed.sql.insert
 import org.jetbrains.exposed.sql.select
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
+import org.kodein.di.DI
+import org.kodein.di.conf.global
+import org.kodein.di.instance
 import uy.kohesive.injekt.injectLazy
 import java.io.File
 import java.io.InputStream
-import java.net.URL
-import java.net.URLClassLoader
-import java.nio.file.Files
-import java.nio.file.Path
 
-private val logger = KotlinLogging.logger {}
+object Extension {
+    private val logger = KotlinLogging.logger {}
+    private val applicationDirs by DI.global.instance<ApplicationDirs>()
 
-private fun dex2jar(dexFile: String, jarFile: String, fileNameWithoutType: String) {
-    // adopted from com.googlecode.dex2jar.tools.Dex2jarCmd.doCommandLine
-    // source at: https://github.com/DexPatcher/dex2jar/tree/v2.1-20190905-lanchon/dex-tools/src/main/java/com/googlecode/dex2jar/tools/Dex2jarCmd.java
+    data class InstallableAPK(
+        val apkFilePath: String,
+        val pkgName: String
+    )
 
-    val jarFilePath = File(jarFile).toPath()
-    val reader = MultiDexFileReader.open(Files.readAllBytes(File(dexFile).toPath()))
-    val handler = BaksmaliBaseDexExceptionHandler()
-    Dex2jar
-        .from(reader)
-        .withExceptionHandler(handler)
-        .reUseReg(false)
-        .topoLogicalSort()
-        .skipDebug(true)
-        .optimizeSynchronized(false)
-        .printIR(false)
-        .noCode(false)
-        .skipExceptions(false)
-        .to(jarFilePath)
-    if (handler.hasException()) {
-        val errorFile: Path = File(applicationDirs.extensionsRoot).toPath().resolve("$fileNameWithoutType-error.txt")
-        logger.error(
-            "Detail Error Information in File $errorFile\n" +
-                "Please report this file to one of following link if possible (any one).\n" +
-                "    https://sourceforge.net/p/dex2jar/tickets/\n" +
-                "    https://bitbucket.org/pxb1988/dex2jar/issues\n" +
-                "    https://github.com/pxb1988/dex2jar/issues\n" +
-                "    dex2jar@googlegroups.com"
-        )
-        handler.dump(errorFile, emptyArray<String>())
+    suspend fun installExtension(pkgName: String): Int {
+        logger.debug("Installing $pkgName")
+        val extensionRecord = extensionTableAsDataClass().first { it.pkgName == pkgName }
+
+        return installAPK {
+            val apkURL = ExtensionGithubApi.getApkUrl(extensionRecord)
+            val apkName = Uri.parse(apkURL).lastPathSegment!!
+            val apkSavePath = "${applicationDirs.extensionsRoot}/$apkName"
+            // download apk file
+            downloadAPKFile(apkURL, apkSavePath)
+
+            apkSavePath
+        }
     }
-}
 
-fun installAPK(apkName: String): Int {
-    logger.debug("Installing $apkName")
-    val extensionRecord = getExtensionList(true).first { it.apkName == apkName }
-    val fileNameWithoutType = apkName.substringBefore(".apk")
-    val dirPathWithoutType = "${applicationDirs.extensionsRoot}/$fileNameWithoutType"
+    suspend fun installAPK(fetcher: suspend () -> String): Int {
+        val apkFilePath = fetcher()
+        val apkName = File(apkFilePath).name
 
-    // check if we don't have the dex file already downloaded
-    val jarPath = "${applicationDirs.extensionsRoot}/$fileNameWithoutType.jar"
-    if (!File(jarPath).exists()) {
-        runBlocking {
-            val api = ExtensionGithubApi()
-            val apkToDownload = api.getApkUrl(extensionRecord)
+        // check if we don't have the extension already installed
+        // if it's installed and we want to update, it first has to be uninstalled
+        val isInstalled = transaction {
+            ExtensionTable.select { ExtensionTable.apkName eq apkName }.firstOrNull()
+        }?.get(ExtensionTable.isInstalled) ?: false
 
-            val apkFilePath = "$dirPathWithoutType.apk"
+        if (!isInstalled) {
+            val fileNameWithoutType = apkName.substringBefore(".apk")
+
+            val dirPathWithoutType = "${applicationDirs.extensionsRoot}/$fileNameWithoutType"
             val jarFilePath = "$dirPathWithoutType.jar"
             val dexFilePath = "$dirPathWithoutType.dex"
 
-            // download apk file
-            downloadAPKFile(apkToDownload, apkFilePath)
+            val packageInfo = getPackageInfo(apkFilePath)
+            val pkgName = packageInfo.packageName
 
-            val className: String = APKExtractor.extract_dex_and_read_className(apkFilePath, dexFilePath)
-            logger.debug(className)
-            // dex -> jar
-            dex2jar(dexFilePath, jarFilePath, fileNameWithoutType)
+            if (!packageInfo.reqFeatures.orEmpty().any { it.name == EXTENSION_FEATURE }) {
+                throw Exception("This apk is not a Tachiyomi extension")
+            }
+
+            // Validate lib version
+            val libVersion = packageInfo.versionName.substringBeforeLast('.').toDouble()
+            if (libVersion < LIB_VERSION_MIN || libVersion > LIB_VERSION_MAX) {
+                throw Exception(
+                    "Lib version is $libVersion, while only versions " +
+                        "$LIB_VERSION_MIN to $LIB_VERSION_MAX are allowed"
+                )
+            }
+
+            val signatureHash = getSignatureHash(packageInfo)
+
+            if (signatureHash == null) {
+                throw Exception("Package $pkgName isn't signed")
+            } else if (signatureHash !in trustedSignatures) {
+                // TODO: allow trusting keys
+                throw Exception("This apk is not a signed with the official tachiyomi signature")
+            }
+
+            val isNsfw = packageInfo.applicationInfo.metaData.getString(METADATA_NSFW) == "1"
+
+            val className = packageInfo.packageName + packageInfo.applicationInfo.metaData.getString(METADATA_SOURCE_CLASS)
+
+            logger.debug("Main class for extension is $className")
+
+            dex2jar(apkFilePath, jarFilePath, fileNameWithoutType)
 
             // clean up
-            File(apkFilePath).delete()
+//            File(apkFilePath).delete()
             File(dexFilePath).delete()
 
-            // update sources of the extension
-            val child = URLClassLoader(arrayOf<URL>(URL("file:$jarFilePath")), this::class.java.classLoader)
-            val classToLoad = Class.forName(className, true, child)
-            val instance = classToLoad.newInstance()
+            // collect sources from the extension
+            val sources: List<CatalogueSource> = when (val instance = loadExtensionSources(jarFilePath, className)) {
+                is Source -> listOf(instance)
+                is SourceFactory -> instance.createSources()
+                else -> throw RuntimeException("Unknown source class type! ${instance.javaClass}")
+            }.map { it as CatalogueSource }
 
-            val extensionId = transaction {
-                return@transaction ExtensionTable.select { ExtensionTable.name eq extensionRecord.name }.first()[ExtensionTable.id]
+            val langs = sources.map { it.lang }.toSet()
+            val extensionLang = when (langs.size) {
+                0 -> ""
+                1 -> langs.first()
+                else -> "all"
             }
 
-            if (instance is HttpSource) { // single source
-                val httpSource = instance as HttpSource
-                transaction {
-                    if (SourceTable.select { SourceTable.id eq httpSource.id }.count() == 0L) {
-                        SourceTable.insert {
-                            it[this.id] = httpSource.id
-                            it[name] = httpSource.name
-                            it[this.lang] = httpSource.lang
-                            it[extension] = extensionId
-                        }
-                    }
-                    logger.debug("Installed source ${httpSource.name} with id ${httpSource.id}")
-                }
-            } else { // multi source
-                val sourceFactory = instance as SourceFactory
-                transaction {
-                    sourceFactory.createSources().forEachIndexed { index, source ->
-                        val httpSource = source as HttpSource
-                        if (SourceTable.select { SourceTable.id eq httpSource.id }.count() == 0L) {
-                            SourceTable.insert {
-                                it[this.id] = httpSource.id
-                                it[name] = httpSource.name
-                                it[this.lang] = httpSource.lang
-                                it[extension] = extensionId
-                                it[partOfFactorySource] = true
-                                it[positionInFactorySource] = index
-                            }
-                        }
-                        logger.debug("Installed source ${httpSource.name} with id:${httpSource.id}")
-                    }
-                }
-            }
+            val extensionName = packageInfo.applicationInfo.nonLocalizedLabel.toString().substringAfter("Tachiyomi: ")
 
             // update extension info
             transaction {
-                ExtensionTable.update({ ExtensionTable.name eq extensionRecord.name }) {
-                    it[installed] = true
-                    it[classFQName] = className
+                if (ExtensionTable.select { ExtensionTable.pkgName eq pkgName }.firstOrNull() == null) {
+                    ExtensionTable.insert {
+                        it[this.apkName] = apkName
+                        it[name] = extensionName
+                        it[this.pkgName] = packageInfo.packageName
+                        it[versionName] = packageInfo.versionName
+                        it[versionCode] = packageInfo.versionCode
+                        it[lang] = extensionLang
+                        it[this.isNsfw] = isNsfw
+                    }
+                }
+
+                ExtensionTable.update({ ExtensionTable.pkgName eq pkgName }) {
+                    it[this.isInstalled] = true
+                    it[this.classFQName] = className
+                }
+
+                val extensionId = ExtensionTable.select { ExtensionTable.pkgName eq pkgName }.firstOrNull()!![ExtensionTable.id].value
+
+                sources.forEach { httpSource ->
+                    SourceTable.insert {
+                        it[id] = httpSource.id
+                        it[name] = httpSource.name
+                        it[lang] = httpSource.lang
+                        it[extension] = extensionId
+                    }
+                    logger.debug("Installed source ${httpSource.name} (${httpSource.lang}) with id:${httpSource.id}")
                 }
             }
-        }
-        return 201 // we downloaded successfully
-    } else {
-        return 302
-    }
-}
-
-val networkHelper: NetworkHelper by injectLazy()
-
-private fun downloadAPKFile(url: String, apkPath: String) {
-    val request = Request.Builder().url(url).build()
-    val response = networkHelper.client.newCall(request).execute()
-
-    val downloadedFile = File(apkPath)
-    val sink = downloadedFile.sink().buffer()
-    sink.writeAll(response.body!!.source())
-    sink.close()
-}
-
-fun removeExtension(apkName: String) {
-    logger.debug("Uninstalling $apkName")
-
-    val extensionRecord = getExtensionList(true).first { it.apkName == apkName }
-    val fileNameWithoutType = apkName.substringBefore(".apk")
-    val jarPath = "${applicationDirs.extensionsRoot}/$fileNameWithoutType.jar"
-    transaction {
-        val extensionId = ExtensionTable.select { ExtensionTable.name eq extensionRecord.name }.first()[ExtensionTable.id]
-
-        SourceTable.deleteWhere { SourceTable.extension eq extensionId }
-        ExtensionTable.update({ ExtensionTable.name eq extensionRecord.name }) {
-            it[ExtensionTable.installed] = false
+            return 201 // we installed successfully
+        } else {
+            return 302 // extension was already installed
         }
     }
 
-    if (File(jarPath).exists()) {
-        File(jarPath).delete()
+    private val network: NetworkHelper by injectLazy()
+
+    private suspend fun downloadAPKFile(url: String, savePath: String) {
+        val request = Request.Builder().url(url).build()
+        val response = network.client.newCall(request).await()
+
+        val downloadedFile = File(savePath)
+        downloadedFile.sink().buffer().use { sink ->
+            response.body!!.source().use { source ->
+                sink.writeAll(source)
+                sink.flush()
+            }
+        }
+    }
+
+    fun uninstallExtension(pkgName: String) {
+        logger.debug("Uninstalling $pkgName")
+
+        val extensionRecord = transaction { ExtensionTable.select { ExtensionTable.pkgName eq pkgName }.firstOrNull()!! }
+        val fileNameWithoutType = extensionRecord[ExtensionTable.apkName].substringBefore(".apk")
+        val jarPath = "${applicationDirs.extensionsRoot}/$fileNameWithoutType.jar"
+        transaction {
+            val extensionId = extensionRecord[ExtensionTable.id].value
+
+            SourceTable.deleteWhere { SourceTable.extension eq extensionId }
+            if (extensionRecord[ExtensionTable.isObsolete])
+                ExtensionTable.deleteWhere { ExtensionTable.pkgName eq pkgName }
+            else
+                ExtensionTable.update({ ExtensionTable.pkgName eq pkgName }) {
+                    it[isInstalled] = false
+                }
+        }
+
+        if (File(jarPath).exists()) {
+            File(jarPath).delete()
+        }
+    }
+
+    suspend fun updateExtension(pkgName: String): Int {
+        val targetExtension = ExtensionsList.updateMap.remove(pkgName)!!
+        uninstallExtension(pkgName)
+        transaction {
+            ExtensionTable.update({ ExtensionTable.pkgName eq pkgName }) {
+                it[name] = targetExtension.name
+                it[versionName] = targetExtension.versionName
+                it[versionCode] = targetExtension.versionCode
+                it[lang] = targetExtension.lang
+                it[isNsfw] = targetExtension.isNsfw
+                it[apkName] = targetExtension.apkName
+                it[iconUrl] = targetExtension.iconUrl
+                it[hasUpdate] = false
+            }
+        }
+        return installExtension(pkgName)
+    }
+
+    suspend fun getExtensionIcon(apkName: String): Pair<InputStream, String> {
+        val iconUrl = transaction { ExtensionTable.select { ExtensionTable.apkName eq apkName }.firstOrNull()!! }[ExtensionTable.iconUrl]
+
+        val saveDir = "${applicationDirs.extensionsRoot}/icon"
+
+        return getCachedImageResponse(saveDir, apkName) {
+            network.client.newCall(
+                GET(iconUrl)
+            ).await()
+        }
+    }
+
+    fun getExtensionIconUrl(apkName: String): String {
+        return "/api/v1/extension/icon/$apkName"
     }
 }
-
-val network: NetworkHelper by injectLazy()
-
-fun getExtensionIcon(apkName: String): Pair<InputStream, String> {
-    val iconUrl = transaction { ExtensionTable.select { ExtensionTable.apkName eq apkName }.firstOrNull()!! }[ExtensionTable.iconUrl]
-
-    val saveDir = "${applicationDirs.extensionsRoot}/icon"
-
-    return getCachedImageResponse(saveDir, apkName) {
-        network.client.newCall(
-            GET(iconUrl)
-        ).execute()
-    }
-}
-
-fun getExtensionIconUrl(apkName: String): String {
-    return "/api/v1/extension/icon/$apkName"
-}

server/src/main/kotlin/ir/armor/tachidesk/impl/ExtensionsList.kt

@@ -9,57 +9,85 @@ package ir.armor.tachidesk.impl
 
 import eu.kanade.tachiyomi.extension.api.ExtensionGithubApi
 import eu.kanade.tachiyomi.extension.model.Extension
-import ir.armor.tachidesk.database.dataclass.ExtensionDataClass
-import ir.armor.tachidesk.database.table.ExtensionTable
-import kotlinx.coroutines.runBlocking
+import ir.armor.tachidesk.impl.Extension.getExtensionIconUrl
+import ir.armor.tachidesk.model.database.ExtensionTable
+import ir.armor.tachidesk.model.dataclass.ExtensionDataClass
 import mu.KotlinLogging
+import org.jetbrains.exposed.sql.deleteWhere
 import org.jetbrains.exposed.sql.insert
 import org.jetbrains.exposed.sql.select
 import org.jetbrains.exposed.sql.selectAll
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
+import java.util.concurrent.ConcurrentHashMap
 
-private val logger = KotlinLogging.logger {}
+object ExtensionsList {
+    private val logger = KotlinLogging.logger {}
 
-private object Data {
-    var lastExtensionCheck: Long = 0
-}
+    var lastUpdateCheck: Long = 0
+    var updateMap = ConcurrentHashMap<String, Extension.Available>()
 
-private fun extensionDatabaseIsEmtpy(): Boolean {
-    return transaction {
-        return@transaction ExtensionTable.selectAll().count() == 0L
+    /** 60,000 milliseconds = 60 seconds */
+    private const val ExtensionUpdateDelayTime = 60 * 1000
+
+    suspend fun getExtensionList(): List<ExtensionDataClass> {
+        // update if {ExtensionUpdateDelayTime} seconds has passed or requested offline and database is empty
+        if (lastUpdateCheck + ExtensionUpdateDelayTime < System.currentTimeMillis()) {
+            logger.debug("Getting extensions list from the internet")
+            lastUpdateCheck = System.currentTimeMillis()
+
+            val foundExtensions = ExtensionGithubApi.findExtensions()
+            updateExtensionDatabase(foundExtensions)
+        } else {
+            logger.debug("used cached extension list")
+        }
+
+        return extensionTableAsDataClass()
     }
-}
 
-fun getExtensionList(offline: Boolean = false): List<ExtensionDataClass> {
-    // update if 60 seconds has passed or requested offline and database is empty
-    if (Data.lastExtensionCheck + 60 * 1000 < System.currentTimeMillis() || (offline && extensionDatabaseIsEmtpy())) {
-        logger.debug("Getting extensions list from the internet")
-        Data.lastExtensionCheck = System.currentTimeMillis()
-        var foundExtensions: List<Extension.Available>
-        runBlocking {
-            val api = ExtensionGithubApi()
-            foundExtensions = api.findExtensions()
-            transaction {
-                foundExtensions.forEach { foundExtension ->
-                    val extensionRecord = ExtensionTable.select { ExtensionTable.name eq foundExtension.name }.firstOrNull()
-                    if (extensionRecord != null) {
-                        // update the record
-                        ExtensionTable.update({ ExtensionTable.name eq foundExtension.name }) {
-                            it[name] = foundExtension.name
-                            it[pkgName] = foundExtension.pkgName
-                            it[versionName] = foundExtension.versionName
-                            it[versionCode] = foundExtension.versionCode
-                            it[lang] = foundExtension.lang
-                            it[isNsfw] = foundExtension.isNsfw
-                            it[apkName] = foundExtension.apkName
-                            it[iconUrl] = foundExtension.iconUrl
+    fun extensionTableAsDataClass() = transaction {
+        ExtensionTable.selectAll().map {
+            ExtensionDataClass(
+                it[ExtensionTable.apkName],
+                getExtensionIconUrl(it[ExtensionTable.apkName]),
+                it[ExtensionTable.name],
+                it[ExtensionTable.pkgName],
+                it[ExtensionTable.versionName],
+                it[ExtensionTable.versionCode],
+                it[ExtensionTable.lang],
+                it[ExtensionTable.isNsfw],
+                it[ExtensionTable.isInstalled],
+                it[ExtensionTable.hasUpdate],
+                it[ExtensionTable.isObsolete],
+            )
+        }
+    }
+
+    private fun updateExtensionDatabase(foundExtensions: List<Extension.Available>) {
+        transaction {
+            foundExtensions.forEach { foundExtension ->
+                val extensionRecord = ExtensionTable.select { ExtensionTable.pkgName eq foundExtension.pkgName }.firstOrNull()
+                if (extensionRecord != null) {
+                    if (extensionRecord[ExtensionTable.isInstalled]) {
+                        when {
+                            foundExtension.versionCode > extensionRecord[ExtensionTable.versionCode] -> {
+                                // there is an update
+                                ExtensionTable.update({ ExtensionTable.pkgName eq foundExtension.pkgName }) {
+                                    it[hasUpdate] = true
+                                }
+                                updateMap.putIfAbsent(foundExtension.pkgName, foundExtension)
+                            }
+                            foundExtension.versionCode < extensionRecord[ExtensionTable.versionCode] -> {
+                                // some how the user installed an invalid version
+                                ExtensionTable.update({ ExtensionTable.pkgName eq foundExtension.pkgName }) {
+                                    it[isObsolete] = true
+                                }
+                            }
                         }
                     } else {
-                        // insert new record
-                        ExtensionTable.insert {
+                        // extension is not installed so we can overwrite the data without a care
+                        ExtensionTable.update({ ExtensionTable.pkgName eq foundExtension.pkgName }) {
                             it[name] = foundExtension.name
-                            it[pkgName] = foundExtension.pkgName
                             it[versionName] = foundExtension.versionName
                             it[versionCode] = foundExtension.versionCode
                             it[lang] = foundExtension.lang
@@ -68,27 +96,37 @@ fun getExtensionList(offline: Boolean = false): List<ExtensionDataClass> {
                             it[iconUrl] = foundExtension.iconUrl
                         }
                     }
+                } else {
+                    // insert new record
+                    ExtensionTable.insert {
+                        it[name] = foundExtension.name
+                        it[pkgName] = foundExtension.pkgName
+                        it[versionName] = foundExtension.versionName
+                        it[versionCode] = foundExtension.versionCode
+                        it[lang] = foundExtension.lang
+                        it[isNsfw] = foundExtension.isNsfw
+                        it[apkName] = foundExtension.apkName
+                        it[iconUrl] = foundExtension.iconUrl
+                    }
+                }
+            }
+
+            // deal with obsolete extensions
+            ExtensionTable.selectAll().forEach { extensionRecord ->
+                val foundExtension = foundExtensions.find { it.pkgName == extensionRecord[ExtensionTable.pkgName] }
+                if (foundExtension == null) {
+                    // not in the repo, so this extensions is obsolete
+                    if (extensionRecord[ExtensionTable.isInstalled]) {
+                        // is installed so we should mark it as obsolete
+                        ExtensionTable.update({ ExtensionTable.pkgName eq extensionRecord[ExtensionTable.pkgName] }) {
+                            it[isObsolete] = true
+                        }
+                    } else {
+                        // is not installed so we can remove the record without a care
+                        ExtensionTable.deleteWhere { ExtensionTable.pkgName eq extensionRecord[ExtensionTable.pkgName] }
+                    }
                 }
             }
         }
-    } else {
-        logger.debug("used cached extension list")
-    }
-
-    return transaction {
-        return@transaction ExtensionTable.selectAll().map {
-            ExtensionDataClass(
-                it[ExtensionTable.name],
-                it[ExtensionTable.pkgName],
-                it[ExtensionTable.versionName],
-                it[ExtensionTable.versionCode],
-                it[ExtensionTable.lang],
-                it[ExtensionTable.isNsfw],
-                it[ExtensionTable.apkName],
-                getExtensionIconUrl(it[ExtensionTable.apkName]),
-                it[ExtensionTable.installed],
-                it[ExtensionTable.classFQName]
-            )
-        }
     }
 }

server/src/main/kotlin/ir/armor/tachidesk/impl/Library.kt

@@ -7,44 +7,50 @@ package ir.armor.tachidesk.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 ir.armor.tachidesk.database.dataclass.MangaDataClass
-import ir.armor.tachidesk.database.table.CategoryMangaTable
-import ir.armor.tachidesk.database.table.MangaTable
-import ir.armor.tachidesk.database.table.toDataClass
+import ir.armor.tachidesk.impl.Manga.getManga
+import ir.armor.tachidesk.model.database.CategoryMangaTable
+import ir.armor.tachidesk.model.database.MangaTable
+import ir.armor.tachidesk.model.database.toDataClass
+import ir.armor.tachidesk.model.dataclass.MangaDataClass
 import org.jetbrains.exposed.sql.and
 import org.jetbrains.exposed.sql.deleteWhere
 import org.jetbrains.exposed.sql.select
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
 
-fun addMangaToLibrary(mangaId: Int) {
-    val manga = getManga(mangaId)
-    if (!manga.inLibrary) {
-        transaction {
-            MangaTable.update({ MangaTable.id eq manga.id }) {
-                it[inLibrary] = true
+object Library {
+// TODO: `Category.isLanding` is to handle the default categories a new library manga gets,
+// ..implement that shit at some time...
+// ..also Consider to rename it to `isDefault`
+    suspend fun addMangaToLibrary(mangaId: Int) {
+        val manga = getManga(mangaId)
+        if (!manga.inLibrary) {
+            transaction {
+                MangaTable.update({ MangaTable.id eq manga.id }) {
+                    it[inLibrary] = true
+                }
+            }
+        }
+    }
+
+    suspend fun removeMangaFromLibrary(mangaId: Int) {
+        val manga = getManga(mangaId)
+        if (manga.inLibrary) {
+            transaction {
+                MangaTable.update({ MangaTable.id eq manga.id }) {
+                    it[inLibrary] = false
+                    it[defaultCategory] = true
+                }
+                CategoryMangaTable.deleteWhere { CategoryMangaTable.manga eq mangaId }
+            }
+        }
+    }
+
+    fun getLibraryMangas(): List<MangaDataClass> {
+        return transaction {
+            MangaTable.select { (MangaTable.inLibrary eq true) and (MangaTable.defaultCategory eq true) }.map {
+                MangaTable.toDataClass(it)
             }
         }
     }
 }
-
-fun removeMangaFromLibrary(mangaId: Int) {
-    val manga = getManga(mangaId)
-    if (manga.inLibrary) {
-        transaction {
-            MangaTable.update({ MangaTable.id eq manga.id }) {
-                it[inLibrary] = false
-                it[defaultCategory] = true
-            }
-            CategoryMangaTable.deleteWhere { CategoryMangaTable.manga eq mangaId }
-        }
-    }
-}
-
-fun getLibraryMangas(): List<MangaDataClass> {
-    return transaction {
-        MangaTable.select { (MangaTable.inLibrary eq true) and (MangaTable.defaultCategory eq true) }.map {
-            MangaTable.toDataClass(it)
-        }
-    }
-}

server/src/main/kotlin/ir/armor/tachidesk/impl/Manga.kt

@@ -9,100 +9,112 @@ package ir.armor.tachidesk.impl
 
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.source.model.SManga
-import ir.armor.tachidesk.database.dataclass.MangaDataClass
-import ir.armor.tachidesk.database.table.MangaStatus
-import ir.armor.tachidesk.database.table.MangaTable
-import ir.armor.tachidesk.server.applicationDirs
+import ir.armor.tachidesk.impl.MangaList.proxyThumbnailUrl
+import ir.armor.tachidesk.impl.Source.getSource
+import ir.armor.tachidesk.impl.util.CachedImageResponse.getCachedImageResponse
+import ir.armor.tachidesk.impl.util.GetHttpSource.getHttpSource
+import ir.armor.tachidesk.impl.util.await
+import ir.armor.tachidesk.impl.util.awaitSingle
+import ir.armor.tachidesk.model.database.MangaStatus
+import ir.armor.tachidesk.model.database.MangaTable
+import ir.armor.tachidesk.model.dataclass.MangaDataClass
+import ir.armor.tachidesk.server.ApplicationDirs
 import org.jetbrains.exposed.sql.select
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
+import org.kodein.di.DI
+import org.kodein.di.conf.global
+import org.kodein.di.instance
 import java.io.InputStream
 
-fun getManga(mangaId: Int, proxyThumbnail: Boolean = true): MangaDataClass {
-    var mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
+object Manga {
+    suspend fun getManga(mangaId: Int, proxyThumbnail: Boolean = true): MangaDataClass {
+        var mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
 
-    return if (mangaEntry[MangaTable.initialized]) {
-        MangaDataClass(
-            mangaId,
-            mangaEntry[MangaTable.sourceReference].toString(),
+        return if (mangaEntry[MangaTable.initialized]) {
+            MangaDataClass(
+                mangaId,
+                mangaEntry[MangaTable.sourceReference].toString(),
 
-            mangaEntry[MangaTable.url],
-            mangaEntry[MangaTable.title],
-            if (proxyThumbnail) proxyThumbnailUrl(mangaId) else mangaEntry[MangaTable.thumbnail_url],
+                mangaEntry[MangaTable.url],
+                mangaEntry[MangaTable.title],
+                if (proxyThumbnail) proxyThumbnailUrl(mangaId) else mangaEntry[MangaTable.thumbnail_url],
 
-            true,
+                true,
 
-            mangaEntry[MangaTable.artist],
-            mangaEntry[MangaTable.author],
-            mangaEntry[MangaTable.description],
-            mangaEntry[MangaTable.genre],
-            MangaStatus.valueOf(mangaEntry[MangaTable.status]).name,
-            mangaEntry[MangaTable.inLibrary],
-            getSource(mangaEntry[MangaTable.sourceReference])
-        )
-    } else { // initialize manga
-        val source = getHttpSource(mangaEntry[MangaTable.sourceReference])
-        val fetchedManga = source.fetchMangaDetails(
-            SManga.create().apply {
-                url = mangaEntry[MangaTable.url]
-                title = mangaEntry[MangaTable.title]
+                mangaEntry[MangaTable.artist],
+                mangaEntry[MangaTable.author],
+                mangaEntry[MangaTable.description],
+                mangaEntry[MangaTable.genre],
+                MangaStatus.valueOf(mangaEntry[MangaTable.status]).name,
+                mangaEntry[MangaTable.inLibrary],
+                getSource(mangaEntry[MangaTable.sourceReference])
+            )
+        } else { // initialize manga
+            val source = getHttpSource(mangaEntry[MangaTable.sourceReference])
+            val fetchedManga = source.fetchMangaDetails(
+                SManga.create().apply {
+                    url = mangaEntry[MangaTable.url]
+                    title = mangaEntry[MangaTable.title]
+                }
+            ).awaitSingle()
+
+            transaction {
+                MangaTable.update({ MangaTable.id eq mangaId }) {
+
+                    it[MangaTable.initialized] = true
+
+                    it[MangaTable.artist] = fetchedManga.artist
+                    it[MangaTable.author] = fetchedManga.author
+                    it[MangaTable.description] = fetchedManga.description
+                    it[MangaTable.genre] = fetchedManga.genre
+                    it[MangaTable.status] = fetchedManga.status
+                    if (fetchedManga.thumbnail_url != null && fetchedManga.thumbnail_url!!.isNotEmpty())
+                        it[MangaTable.thumbnail_url] = fetchedManga.thumbnail_url
+                }
             }
-        ).toBlocking().first()
 
-        transaction {
-            MangaTable.update({ MangaTable.id eq mangaId }) {
+            mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
+            val newThumbnail = mangaEntry[MangaTable.thumbnail_url]
 
-                it[MangaTable.initialized] = true
+            MangaDataClass(
+                mangaId,
+                mangaEntry[MangaTable.sourceReference].toString(),
 
-                it[MangaTable.artist] = fetchedManga.artist
-                it[MangaTable.author] = fetchedManga.author
-                it[MangaTable.description] = fetchedManga.description
-                it[MangaTable.genre] = fetchedManga.genre
-                it[MangaTable.status] = fetchedManga.status
-                if (fetchedManga.thumbnail_url != null && fetchedManga.thumbnail_url!!.isNotEmpty())
-                    it[MangaTable.thumbnail_url] = fetchedManga.thumbnail_url
-            }
+                mangaEntry[MangaTable.url],
+                mangaEntry[MangaTable.title],
+                if (proxyThumbnail) proxyThumbnailUrl(mangaId) else newThumbnail,
+
+                true,
+
+                fetchedManga.artist,
+                fetchedManga.author,
+                fetchedManga.description,
+                fetchedManga.genre,
+                MangaStatus.valueOf(fetchedManga.status).name,
+                false,
+                getSource(mangaEntry[MangaTable.sourceReference])
+            )
         }
+    }
 
-        mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
-        val newThumbnail = mangaEntry[MangaTable.thumbnail_url]
+    private val applicationDirs by DI.global.instance<ApplicationDirs>()
+    suspend fun getMangaThumbnail(mangaId: Int): Pair<InputStream, String> {
+        val mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
+        val saveDir = applicationDirs.thumbnailsRoot
+        val fileName = mangaId.toString()
 
-        MangaDataClass(
-            mangaId,
-            mangaEntry[MangaTable.sourceReference].toString(),
+        return getCachedImageResponse(saveDir, fileName) {
+            val sourceId = mangaEntry[MangaTable.sourceReference]
+            val source = getHttpSource(sourceId)
+            var thumbnailUrl = mangaEntry[MangaTable.thumbnail_url]
+            if (thumbnailUrl == null || thumbnailUrl.isEmpty()) {
+                thumbnailUrl = getManga(mangaId, proxyThumbnail = false).thumbnailUrl!!
+            }
 
-            mangaEntry[MangaTable.url],
-            mangaEntry[MangaTable.title],
-            if (proxyThumbnail) proxyThumbnailUrl(mangaId) else newThumbnail,
-
-            true,
-
-            fetchedManga.artist,
-            fetchedManga.author,
-            fetchedManga.description,
-            fetchedManga.genre,
-            MangaStatus.valueOf(fetchedManga.status).name,
-            false,
-            getSource(mangaEntry[MangaTable.sourceReference])
-        )
-    }
-}
-
-fun getThumbnail(mangaId: Int): Pair<InputStream, String> {
-    val mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
-    val saveDir = applicationDirs.thumbnailsRoot
-    val fileName = mangaId.toString()
-
-    return getCachedImageResponse(saveDir, fileName) {
-        val sourceId = mangaEntry[MangaTable.sourceReference]
-        val source = getHttpSource(sourceId)
-        var thumbnailUrl = mangaEntry[MangaTable.thumbnail_url]
-        if (thumbnailUrl == null || thumbnailUrl.isEmpty()) {
-            thumbnailUrl = getManga(mangaId, proxyThumbnail = false).thumbnailUrl!!
-        }
-
-        source.client.newCall(
-            GET(thumbnailUrl, source.headers)
-        ).execute()
+            source.client.newCall(
+                GET(thumbnailUrl, source.headers)
+            ).await()
+        }
     }
 }

server/src/main/kotlin/ir/armor/tachidesk/impl/MangaList.kt

@@ -8,91 +8,95 @@ package ir.armor.tachidesk.impl
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 import eu.kanade.tachiyomi.source.model.MangasPage
-import ir.armor.tachidesk.database.dataclass.MangaDataClass
-import ir.armor.tachidesk.database.dataclass.PagedMangaListDataClass
-import ir.armor.tachidesk.database.table.MangaStatus
-import ir.armor.tachidesk.database.table.MangaTable
+import ir.armor.tachidesk.impl.util.GetHttpSource.getHttpSource
+import ir.armor.tachidesk.impl.util.awaitSingle
+import ir.armor.tachidesk.model.database.MangaStatus
+import ir.armor.tachidesk.model.database.MangaTable
+import ir.armor.tachidesk.model.dataclass.MangaDataClass
+import ir.armor.tachidesk.model.dataclass.PagedMangaListDataClass
 import org.jetbrains.exposed.sql.insertAndGetId
 import org.jetbrains.exposed.sql.select
 import org.jetbrains.exposed.sql.transactions.transaction
 
-fun proxyThumbnailUrl(mangaId: Int): String {
-    return "/api/v1/manga/$mangaId/thumbnail"
-}
-
-fun getMangaList(sourceId: Long, pageNum: Int = 1, popular: Boolean): PagedMangaListDataClass {
-    val source = getHttpSource(sourceId.toLong())
-    val mangasPage = if (popular) {
-        source.fetchPopularManga(pageNum).toBlocking().first()
-    } else {
-        if (source.supportsLatest)
-            source.fetchLatestUpdates(pageNum).toBlocking().first()
-        else
-            throw Exception("Source $source doesn't support latest")
+object MangaList {
+    fun proxyThumbnailUrl(mangaId: Int): String {
+        return "/api/v1/manga/$mangaId/thumbnail"
     }
-    return mangasPage.processEntries(sourceId)
-}
 
-fun MangasPage.processEntries(sourceId: Long): PagedMangaListDataClass {
-    val mangasPage = this
-    val mangaList = transaction {
-        return@transaction mangasPage.mangas.map { manga ->
-            var mangaEntry = MangaTable.select { MangaTable.url eq manga.url }.firstOrNull()
-            if (mangaEntry == null) { // create manga entry
-                val mangaId = MangaTable.insertAndGetId {
-                    it[url] = manga.url
-                    it[title] = manga.title
+    suspend fun getMangaList(sourceId: Long, pageNum: Int = 1, popular: Boolean): PagedMangaListDataClass {
+        val source = getHttpSource(sourceId)
+        val mangasPage = if (popular) {
+            source.fetchPopularManga(pageNum).awaitSingle()
+        } else {
+            if (source.supportsLatest)
+                source.fetchLatestUpdates(pageNum).awaitSingle()
+            else
+                throw Exception("Source $source doesn't support latest")
+        }
+        return mangasPage.processEntries(sourceId)
+    }
 
-                    it[artist] = manga.artist
-                    it[author] = manga.author
-                    it[description] = manga.description
-                    it[genre] = manga.genre
-                    it[status] = manga.status
-                    it[thumbnail_url] = manga.thumbnail_url
+    fun MangasPage.processEntries(sourceId: Long): PagedMangaListDataClass {
+        val mangasPage = this
+        val mangaList = transaction {
+            return@transaction mangasPage.mangas.map { manga ->
+                var mangaEntry = MangaTable.select { MangaTable.url eq manga.url }.firstOrNull()
+                if (mangaEntry == null) { // create manga entry
+                    val mangaId = MangaTable.insertAndGetId {
+                        it[url] = manga.url
+                        it[title] = manga.title
 
-                    it[sourceReference] = sourceId
-                }.value
+                        it[artist] = manga.artist
+                        it[author] = manga.author
+                        it[description] = manga.description
+                        it[genre] = manga.genre
+                        it[status] = manga.status
+                        it[thumbnail_url] = manga.thumbnail_url
 
-                MangaDataClass(
-                    mangaId,
-                    sourceId.toString(),
+                        it[sourceReference] = sourceId
+                    }.value
 
-                    manga.url,
-                    manga.title,
-                    proxyThumbnailUrl(mangaId),
+                    MangaDataClass(
+                        mangaId,
+                        sourceId.toString(),
 
-                    manga.initialized,
+                        manga.url,
+                        manga.title,
+                        proxyThumbnailUrl(mangaId),
 
-                    manga.artist,
-                    manga.author,
-                    manga.description,
-                    manga.genre,
-                    MangaStatus.valueOf(manga.status).name
-                )
-            } else {
-                val mangaId = mangaEntry[MangaTable.id].value
-                MangaDataClass(
-                    mangaId,
-                    sourceId.toString(),
+                        manga.initialized,
 
-                    manga.url,
-                    manga.title,
-                    proxyThumbnailUrl(mangaId),
+                        manga.artist,
+                        manga.author,
+                        manga.description,
+                        manga.genre,
+                        MangaStatus.valueOf(manga.status).name
+                    )
+                } else {
+                    val mangaId = mangaEntry[MangaTable.id].value
+                    MangaDataClass(
+                        mangaId,
+                        sourceId.toString(),
 
-                    true,
+                        manga.url,
+                        manga.title,
+                        proxyThumbnailUrl(mangaId),
 
-                    mangaEntry[MangaTable.artist],
-                    mangaEntry[MangaTable.author],
-                    mangaEntry[MangaTable.description],
-                    mangaEntry[MangaTable.genre],
-                    MangaStatus.valueOf(mangaEntry[MangaTable.status]).name,
-                    mangaEntry[MangaTable.inLibrary]
-                )
+                        true,
+
+                        mangaEntry[MangaTable.artist],
+                        mangaEntry[MangaTable.author],
+                        mangaEntry[MangaTable.description],
+                        mangaEntry[MangaTable.genre],
+                        MangaStatus.valueOf(mangaEntry[MangaTable.status]).name,
+                        mangaEntry[MangaTable.inLibrary]
+                    )
+                }
             }
         }
+        return PagedMangaListDataClass(
+            mangaList,
+            mangasPage.hasNextPage
+        )
     }
-    return PagedMangaListDataClass(
-        mangaList,
-        mangasPage.hasNextPage
-    )
 }

server/src/main/kotlin/ir/armor/tachidesk/impl/Page.kt

@@ -9,77 +9,92 @@ package ir.armor.tachidesk.impl
 
 import eu.kanade.tachiyomi.source.model.Page
 import eu.kanade.tachiyomi.source.online.HttpSource
-import ir.armor.tachidesk.database.table.ChapterTable
-import ir.armor.tachidesk.database.table.MangaTable
-import ir.armor.tachidesk.database.table.PageTable
-import ir.armor.tachidesk.database.table.SourceTable
-import ir.armor.tachidesk.server.applicationDirs
+import ir.armor.tachidesk.impl.util.CachedImageResponse.getCachedImageResponse
+import ir.armor.tachidesk.impl.util.GetHttpSource.getHttpSource
+import ir.armor.tachidesk.impl.util.awaitSingle
+import ir.armor.tachidesk.model.database.ChapterTable
+import ir.armor.tachidesk.model.database.MangaTable
+import ir.armor.tachidesk.model.database.PageTable
+import ir.armor.tachidesk.model.database.SourceTable
+import ir.armor.tachidesk.server.ApplicationDirs
 import org.jetbrains.exposed.sql.and
 import org.jetbrains.exposed.sql.select
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
+import org.kodein.di.DI
+import org.kodein.di.conf.global
+import org.kodein.di.instance
 import java.io.File
 import java.io.InputStream
 
-fun getTrueImageUrl(page: Page, source: HttpSource): String {
-    if (page.imageUrl == null) {
-        page.imageUrl = source.fetchImageUrl(page).toBlocking().first()!!
+object Page {
+/**
+     * A page might have a imageUrl ready from the get go, or we might need to
+     * go an extra step and call fetchImageUrl to get it.
+     */
+    suspend fun getTrueImageUrl(page: Page, source: HttpSource): String {
+        if (page.imageUrl == null) {
+            page.imageUrl = source.fetchImageUrl(page).awaitSingle()
+        }
+        return page.imageUrl!!
     }
-    return page.imageUrl!!
-}
 
-fun getPageImage(mangaId: Int, chapterIndex: Int, index: Int): Pair<InputStream, String> {
-    val mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
-    val source = getHttpSource(mangaEntry[MangaTable.sourceReference])
-    val chapterEntry = transaction {
-        ChapterTable.select {
-            (ChapterTable.chapterIndex eq chapterIndex) and (ChapterTable.manga eq mangaId)
-        }.firstOrNull()!!
-    }
-    val chapterId = chapterEntry[ChapterTable.id].value
+    suspend fun getPageImage(mangaId: Int, chapterIndex: Int, index: Int): Pair<InputStream, String> {
+        val mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
+        val source = getHttpSource(mangaEntry[MangaTable.sourceReference])
+        val chapterEntry = transaction {
+            ChapterTable.select {
+                (ChapterTable.chapterIndex eq chapterIndex) and (ChapterTable.manga eq mangaId)
+            }.firstOrNull()!!
+        }
+        val chapterId = chapterEntry[ChapterTable.id].value
 
-    val pageEntry = transaction { PageTable.select { (PageTable.chapter eq chapterId) and (PageTable.index eq index) }.firstOrNull()!! }
+        val pageEntry = transaction { PageTable.select { (PageTable.chapter eq chapterId) and (PageTable.index eq index) }.firstOrNull()!! }
 
-    val tachiPage = Page(
-        pageEntry[PageTable.index],
-        pageEntry[PageTable.url],
-        pageEntry[PageTable.imageUrl]
-    )
+        val tachiPage = Page(
+            pageEntry[PageTable.index],
+            pageEntry[PageTable.url],
+            pageEntry[PageTable.imageUrl]
+        )
 
-    if (pageEntry[PageTable.imageUrl] == null) {
-        transaction {
-            PageTable.update({ (PageTable.chapter eq chapterId) and (PageTable.index eq index) }) {
-                it[imageUrl] = getTrueImageUrl(tachiPage, source)
+        if (pageEntry[PageTable.imageUrl] == null) {
+            val trueImageUrl = getTrueImageUrl(tachiPage, source)
+            transaction {
+                PageTable.update({ (PageTable.chapter eq chapterId) and (PageTable.index eq index) }) {
+                    it[imageUrl] = trueImageUrl
+                }
             }
         }
+
+        val saveDir = getChapterDir(mangaId, chapterId)
+        File(saveDir).mkdirs()
+        val fileName = index.toString()
+
+        return getCachedImageResponse(saveDir, fileName) {
+            source.fetchImage(tachiPage).awaitSingle()
+        }
     }
 
-    val saveDir = getChapterDir(mangaId, chapterId)
-    File(saveDir).mkdirs()
-    val fileName = index.toString()
+// TODO: rewrite this to match tachiyomi
+    private val applicationDirs by DI.global.instance<ApplicationDirs>()
+    fun getChapterDir(mangaId: Int, chapterId: Int): String {
+        val mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
+        val sourceId = mangaEntry[MangaTable.sourceReference]
+        val source = getHttpSource(sourceId)
+        val sourceEntry = transaction { SourceTable.select { SourceTable.id eq sourceId }.firstOrNull()!! }
+        val chapterEntry = transaction { ChapterTable.select { ChapterTable.id eq chapterId }.firstOrNull()!! }
 
-    return getCachedImageResponse(saveDir, fileName) {
-        source.fetchImage(tachiPage).toBlocking().first()
+        val chapterDir = when {
+            chapterEntry[ChapterTable.scanlator] != null -> "${chapterEntry[ChapterTable.scanlator]}_${chapterEntry[ChapterTable.name]}"
+            else -> chapterEntry[ChapterTable.name]
+        }
+
+        val mangaTitle = mangaEntry[MangaTable.title]
+        val sourceName = source.toString()
+
+        val mangaDir = "${applicationDirs.mangaRoot}/$sourceName/$mangaTitle/$chapterDir"
+        // make sure dirs exist
+        File(mangaDir).mkdirs()
+        return mangaDir
     }
 }
-
-fun getChapterDir(mangaId: Int, chapterId: Int): String {
-    val mangaEntry = transaction { MangaTable.select { MangaTable.id eq mangaId }.firstOrNull()!! }
-    val sourceId = mangaEntry[MangaTable.sourceReference]
-    val source = getHttpSource(sourceId)
-    val sourceEntry = transaction { SourceTable.select { SourceTable.id eq sourceId }.firstOrNull()!! }
-    val chapterEntry = transaction { ChapterTable.select { ChapterTable.id eq chapterId }.firstOrNull()!! }
-
-    val chapterDir = when {
-        chapterEntry[ChapterTable.scanlator] != null -> "${chapterEntry[ChapterTable.scanlator]}_${chapterEntry[ChapterTable.name]}"
-        else -> chapterEntry[ChapterTable.name]
-    }
-
-    val mangaTitle = mangaEntry[MangaTable.title]
-    val sourceName = source.toString()
-
-    val mangaDir = "${applicationDirs.mangaRoot}/$sourceName/$mangaTitle/$chapterDir"
-    // make sure dirs exist
-    File(mangaDir).mkdirs()
-    return mangaDir
-}

server/src/main/kotlin/ir/armor/tachidesk/impl/Search.kt

@@ -7,28 +7,36 @@ package ir.armor.tachidesk.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 ir.armor.tachidesk.database.dataclass.PagedMangaListDataClass
+import ir.armor.tachidesk.impl.MangaList.processEntries
+import ir.armor.tachidesk.impl.util.GetHttpSource.getHttpSource
+import ir.armor.tachidesk.impl.util.awaitSingle
+import ir.armor.tachidesk.model.dataclass.PagedMangaListDataClass
 
-fun sourceFilters(sourceId: Long) {
-    val source = getHttpSource(sourceId)
-    // source.getFilterList().toItems()
-}
+object Search {
+// TODO
+    fun sourceFilters(sourceId: Long) {
+        val source = getHttpSource(sourceId)
+        // source.getFilterList().toItems()
+    }
 
-fun sourceSearch(sourceId: Long, searchTerm: String, pageNum: Int): PagedMangaListDataClass {
-    val source = getHttpSource(sourceId)
-    val searchManga = source.fetchSearchManga(pageNum, searchTerm, source.getFilterList()).toBlocking().first()
-    return searchManga.processEntries(sourceId)
-}
+    suspend fun sourceSearch(sourceId: Long, searchTerm: String, pageNum: Int): PagedMangaListDataClass {
+        val source = getHttpSource(sourceId)
+        val searchManga = source.fetchSearchManga(pageNum, searchTerm, source.getFilterList()).awaitSingle()
+        return searchManga.processEntries(sourceId)
+    }
 
-fun sourceGlobalSearch(searchTerm: String) {
-    // TODO
-}
+    fun sourceGlobalSearch(searchTerm: String) {
+        // TODO
+    }
 
-data class FilterWrapper(
-    val type: String,
-    val filter: Any
-)
+    data class FilterWrapper(
+        val type: String,
+        val filter: Any
+    )
 
+/**
+     * Note: Exhentai had a filter serializer (now in SY) that we might be able to steal
+     */
 // private fun FilterList.toFilterWrapper(): List<FilterWrapper> {
 //    return mapNotNull { filter ->
 //        when (filter) {
@@ -64,3 +72,4 @@ data class FilterWrapper(
 //        }
 //    }
 // }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/Source.kt

@@ -0,0 +1,50 @@
+package ir.armor.tachidesk.impl
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 ir.armor.tachidesk.impl.Extension.getExtensionIconUrl
+import ir.armor.tachidesk.impl.util.GetHttpSource.getHttpSource
+import ir.armor.tachidesk.model.database.ExtensionTable
+import ir.armor.tachidesk.model.database.SourceTable
+import ir.armor.tachidesk.model.dataclass.SourceDataClass
+import mu.KotlinLogging
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.selectAll
+import org.jetbrains.exposed.sql.transactions.transaction
+
+object Source {
+    private val logger = KotlinLogging.logger {}
+
+    fun getSourceList(): List<SourceDataClass> {
+        return transaction {
+            SourceTable.selectAll().map {
+                SourceDataClass(
+                    it[SourceTable.id].value.toString(),
+                    it[SourceTable.name],
+                    it[SourceTable.lang],
+                    getExtensionIconUrl(ExtensionTable.select { ExtensionTable.id eq it[SourceTable.extension] }.first()[ExtensionTable.apkName]),
+                    getHttpSource(it[SourceTable.id].value).supportsLatest
+                )
+            }
+        }
+    }
+
+    fun getSource(sourceId: Long): SourceDataClass {
+        return transaction {
+            val source = SourceTable.select { SourceTable.id eq sourceId }.firstOrNull()
+
+            SourceDataClass(
+                sourceId.toString(),
+                source?.get(SourceTable.name),
+                source?.get(SourceTable.lang),
+                source?.let { ExtensionTable.select { ExtensionTable.id eq source[SourceTable.extension] }.first()[ExtensionTable.iconUrl] },
+                source?.let { getHttpSource(sourceId).supportsLatest }
+            )
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/SourceList.kt

@@ -1,107 +0,0 @@
-package ir.armor.tachidesk.impl
-
-/*
- * Copyright (C) Contributors to the Suwayomi project
- * 
- * This Source Code Form is subject to the terms of the Mozilla Public
- * 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 eu.kanade.tachiyomi.source.SourceFactory
-import eu.kanade.tachiyomi.source.online.HttpSource
-import ir.armor.tachidesk.database.dataclass.SourceDataClass
-import ir.armor.tachidesk.database.entity.ExtensionEntity
-import ir.armor.tachidesk.database.entity.SourceEntity
-import ir.armor.tachidesk.database.table.ExtensionTable
-import ir.armor.tachidesk.database.table.SourceTable
-import ir.armor.tachidesk.server.applicationDirs
-import mu.KotlinLogging
-import org.jetbrains.exposed.sql.select
-import org.jetbrains.exposed.sql.selectAll
-import org.jetbrains.exposed.sql.transactions.transaction
-import java.lang.NullPointerException
-import java.net.URL
-import java.net.URLClassLoader
-
-private val logger = KotlinLogging.logger {}
-
-private val sourceCache = mutableListOf<Pair<Long, HttpSource>>()
-private val extensionCache = mutableListOf<Pair<String, Any>>()
-
-fun getHttpSource(sourceId: Long): HttpSource {
-    val sourceRecord = transaction {
-        SourceEntity.findById(sourceId)
-    } ?: throw NullPointerException("Source with id $sourceId is not installed")
-
-    val cachedResult: Pair<Long, HttpSource>? = sourceCache.firstOrNull { it.first == sourceId }
-    if (cachedResult != null) {
-        logger.debug("used cached HttpSource: ${cachedResult.second.name}")
-        return cachedResult.second
-    }
-
-    val result: HttpSource = transaction {
-        val extensionId = sourceRecord.extension.id.value
-        val extensionRecord = ExtensionEntity.findById(extensionId)!!
-        val apkName = extensionRecord.apkName
-        val className = extensionRecord.classFQName
-        val jarName = apkName.substringBefore(".apk") + ".jar"
-        val jarPath = "${applicationDirs.extensionsRoot}/$jarName"
-
-        val cachedExtensionPair = extensionCache.firstOrNull { it.first == jarPath }
-        var usedCached = false
-        val instance =
-            if (cachedExtensionPair != null) {
-                usedCached = true
-                logger.debug("Used cached Extension")
-                cachedExtensionPair.second
-            } else {
-                logger.debug("No Extension cache")
-                val child = URLClassLoader(arrayOf<URL>(URL("file:$jarPath")), this::class.java.classLoader)
-                val classToLoad = Class.forName(className, true, child)
-                classToLoad.newInstance()
-            }
-        if (sourceRecord.partOfFactorySource) {
-            return@transaction if (usedCached) {
-                (instance as List<HttpSource>)[sourceRecord.positionInFactorySource!!]
-            } else {
-                val list = (instance as SourceFactory).createSources()
-                extensionCache.add(Pair(jarPath, list))
-                list[sourceRecord.positionInFactorySource!!] as HttpSource
-            }
-        } else {
-            if (!usedCached)
-                extensionCache.add(Pair(jarPath, instance))
-            return@transaction instance as HttpSource
-        }
-    }
-    sourceCache.add(Pair(sourceId, result))
-    return result
-}
-
-fun getSourceList(): List<SourceDataClass> {
-    return transaction {
-        return@transaction SourceTable.selectAll().map {
-            SourceDataClass(
-                it[SourceTable.id].value.toString(),
-                it[SourceTable.name],
-                it[SourceTable.lang],
-                getExtensionIconUrl(ExtensionTable.select { ExtensionTable.id eq it[SourceTable.extension] }.first()[ExtensionTable.apkName]),
-                getHttpSource(it[SourceTable.id].value).supportsLatest
-            )
-        }
-    }
-}
-
-fun getSource(sourceId: Long): SourceDataClass {
-    return transaction {
-        val source = SourceTable.select { SourceTable.id eq sourceId }.firstOrNull()
-
-        return@transaction SourceDataClass(
-            sourceId.toString(),
-            source?.get(SourceTable.name),
-            source?.get(SourceTable.lang),
-            source?.let { ExtensionTable.select { ExtensionTable.id eq source[SourceTable.extension] }.first()[ExtensionTable.iconUrl] },
-            source?.let { getHttpSource(sourceId).supportsLatest }
-        )
-    }
-}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/BackupFlags.kt

@@ -0,0 +1,16 @@
+package ir.armor.tachidesk.impl.backup
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+data class BackupFlags(
+    val includeManga: Boolean,
+    val includeCategories: Boolean,
+    val includeChapters: Boolean,
+    val includeTracking: Boolean,
+    val includeHistory: Boolean,
+)

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/legacy/LegacyBackupBase.kt

@@ -0,0 +1,45 @@
+package ir.armor.tachidesk.impl.backup.legacy
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 com.github.salomonbrys.kotson.registerTypeAdapter
+import com.github.salomonbrys.kotson.registerTypeHierarchyAdapter
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import ir.armor.tachidesk.impl.backup.legacy.models.DHistory
+import ir.armor.tachidesk.impl.backup.legacy.serializer.CategoryTypeAdapter
+import ir.armor.tachidesk.impl.backup.legacy.serializer.ChapterTypeAdapter
+import ir.armor.tachidesk.impl.backup.legacy.serializer.HistoryTypeAdapter
+import ir.armor.tachidesk.impl.backup.legacy.serializer.MangaTypeAdapter
+import ir.armor.tachidesk.impl.backup.legacy.serializer.TrackTypeAdapter
+import ir.armor.tachidesk.impl.backup.models.CategoryImpl
+import ir.armor.tachidesk.impl.backup.models.ChapterImpl
+import ir.armor.tachidesk.impl.backup.models.MangaImpl
+import ir.armor.tachidesk.impl.backup.models.TrackImpl
+import java.util.Date
+
+open class LegacyBackupBase {
+    protected val parser: Gson = when (version) {
+        2 -> GsonBuilder()
+            .registerTypeAdapter<MangaImpl>(MangaTypeAdapter.build())
+            .registerTypeHierarchyAdapter<ChapterImpl>(ChapterTypeAdapter.build())
+            .registerTypeAdapter<CategoryImpl>(CategoryTypeAdapter.build())
+            .registerTypeAdapter<DHistory>(HistoryTypeAdapter.build())
+            .registerTypeHierarchyAdapter<TrackImpl>(TrackTypeAdapter.build())
+            .create()
+        else -> throw Exception("Unknown backup version")
+    }
+
+    protected var sourceMapping: Map<Long, String> = emptyMap()
+
+    protected val errors = mutableListOf<Pair<Date, String>>()
+
+    companion object {
+        internal const val version = 2
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/legacy/LegacyBackupExport.kt

@@ -0,0 +1,115 @@
+package ir.armor.tachidesk.impl.backup.legacy
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 com.github.salomonbrys.kotson.set
+import com.google.gson.JsonArray
+import com.google.gson.JsonElement
+import com.google.gson.JsonObject
+import eu.kanade.tachiyomi.source.LocalSource
+import ir.armor.tachidesk.impl.backup.BackupFlags
+import ir.armor.tachidesk.impl.backup.legacy.models.Backup
+import ir.armor.tachidesk.impl.backup.legacy.models.Backup.CURRENT_VERSION
+import ir.armor.tachidesk.impl.backup.models.ChapterImpl
+import ir.armor.tachidesk.impl.backup.models.Manga
+import ir.armor.tachidesk.impl.backup.models.MangaImpl
+import ir.armor.tachidesk.impl.util.GetHttpSource.getHttpSource
+import ir.armor.tachidesk.model.database.ChapterTable
+import ir.armor.tachidesk.model.database.MangaTable
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.transactions.transaction
+
+object LegacyBackupExport : LegacyBackupBase() {
+
+    suspend fun createLegacyBackup(flags: BackupFlags): String? {
+        // Create root object
+        val root = JsonObject()
+
+        // Create manga array
+        val mangaEntries = JsonArray()
+
+        // Create category array
+        val categoryEntries = JsonArray()
+
+        // Create extension ID/name mapping
+        val extensionEntries = JsonArray()
+
+        // Add values to root
+        root[Backup.VERSION] = CURRENT_VERSION
+        root[Backup.MANGAS] = mangaEntries
+        root[Backup.CATEGORIES] = categoryEntries
+        root[Backup.EXTENSIONS] = extensionEntries
+
+        transaction {
+            val mangas = MangaTable.select { (MangaTable.inLibrary eq true) }
+
+            val extensions: MutableSet<String> = mutableSetOf()
+
+            // Backup library manga and its dependencies
+            mangas.map {
+                MangaImpl.fromQuery(it)
+            }.forEach { manga ->
+
+                mangaEntries.add(backupMangaObject(manga, flags))
+
+                // Maintain set of extensions/sources used (excludes local source)
+                if (manga.source != LocalSource.ID) {
+                    getHttpSource(manga.source).let {
+                        extensions.add("${it.id}:${it.name}")
+                    }
+                }
+            }
+
+            // Backup categories
+            if (flags.includeCategories) {
+                backupCategories(categoryEntries)
+            }
+
+            // Backup extension ID/name mapping
+            backupExtensionInfo(extensionEntries, extensions)
+        }
+
+        return parser.toJson(root)
+    }
+
+    private fun backupMangaObject(manga: Manga, options: BackupFlags): JsonElement {
+        // Entry for this manga
+        val entry = JsonObject()
+
+        // Backup manga fields
+        entry[Backup.MANGA] = parser.toJsonTree(manga)
+
+        // Check if user wants chapter information in backup
+        if (options.includeChapters && false) { // TODO
+            // Backup all the chapters
+            val mangaId = manga.id!!.toInt()
+            val chapters = ChapterTable.select { ChapterTable.manga eq mangaId }.map { ChapterImpl.fromQuery(it) }
+            if (chapters.count() > 0) {
+                val chaptersJson = parser.toJsonTree(chapters)
+                if (chaptersJson.asJsonArray.size() > 0) {
+                    entry[Backup.CHAPTERS] = chaptersJson
+                }
+            }
+        }
+
+        // TODO the rest
+
+        return entry
+    }
+
+    private fun backupCategories(root: JsonArray) { // TODO
+//        val categories = databaseHelper.getCategories().executeAsBlocking()
+//        categories.forEach { root.add(parser.toJsonTree(it)) }
+    }
+
+    private fun backupExtensionInfo(root: JsonArray, extensions: Set<String>) {
+        extensions.sorted().forEach {
+            root.add(it)
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/legacy/LegacyBackupImport.kt

@@ -0,0 +1,200 @@
+package ir.armor.tachidesk.impl.backup.legacy
+
+import com.github.salomonbrys.kotson.fromJson
+import com.google.gson.JsonArray
+import com.google.gson.JsonElement
+import com.google.gson.JsonObject
+import com.google.gson.JsonParser
+import eu.kanade.tachiyomi.source.Source
+import eu.kanade.tachiyomi.source.model.SManga
+import ir.armor.tachidesk.impl.backup.legacy.LegacyBackupRestoreValidator.ValidationResult
+import ir.armor.tachidesk.impl.backup.legacy.LegacyBackupRestoreValidator.validate
+import ir.armor.tachidesk.impl.backup.legacy.models.Backup
+import ir.armor.tachidesk.impl.backup.legacy.models.DHistory
+import ir.armor.tachidesk.impl.backup.models.Chapter
+import ir.armor.tachidesk.impl.backup.models.ChapterImpl
+import ir.armor.tachidesk.impl.backup.models.Manga
+import ir.armor.tachidesk.impl.backup.models.MangaImpl
+import ir.armor.tachidesk.impl.backup.models.Track
+import ir.armor.tachidesk.impl.backup.models.TrackImpl
+import ir.armor.tachidesk.impl.util.GetHttpSource.getHttpSource
+import ir.armor.tachidesk.impl.util.awaitSingle
+import ir.armor.tachidesk.model.database.MangaTable
+import mu.KotlinLogging
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.jetbrains.exposed.sql.update
+import java.io.InputStream
+import java.util.Date
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+private val logger = KotlinLogging.logger {}
+
+object LegacyBackupImport : LegacyBackupBase() {
+    suspend fun restoreLegacyBackup(sourceStream: InputStream): ValidationResult {
+        val reader = sourceStream.bufferedReader()
+        val json = JsonParser.parseReader(reader).asJsonObject
+
+        val validationResult = validate(json)
+
+        val mangasJson = json.get(Backup.MANGAS).asJsonArray
+
+        // Restore categories
+        json.get(Backup.CATEGORIES)?.let { restoreCategories(it) }
+
+        // Store source mapping for error messages
+        sourceMapping = LegacyBackupRestoreValidator.getSourceMapping(json)
+
+        // Restore individual manga
+        mangasJson.forEach {
+            restoreManga(it.asJsonObject)
+        }
+
+        logger.info {
+            """
+                Restore Errors:
+                ${
+            errors.map {
+                "${it.first} - ${it.second}"
+            }.joinToString("\n")
+            }
+                Restore Summary:
+                - Missing Sources:
+                ${validationResult.missingSources.joinToString("\n")}
+                - Missing Trackers:
+                ${validationResult.missingTrackers.joinToString("\n")}
+            """.trimIndent()
+        }
+
+        return validationResult
+    }
+
+    private fun restoreCategories(categoriesJson: JsonElement) { // TODO
+//        db.inTransaction {
+//            backupManager.restoreCategories(categoriesJson.asJsonArray)
+//        }
+//
+//        restoreProgress += 1
+//        showRestoreProgress(restoreProgress, restoreAmount, context.getString(R.string.categories))
+    }
+
+    private suspend fun restoreManga(mangaJson: JsonObject) {
+        val manga = parser.fromJson<MangaImpl>(
+            mangaJson.get(
+                Backup.MANGA
+            )
+        )
+        val chapters = parser.fromJson<List<ChapterImpl>>(
+            mangaJson.get(Backup.CHAPTERS)
+                ?: JsonArray()
+        )
+        val categories = parser.fromJson<List<String>>(
+            mangaJson.get(Backup.CATEGORIES)
+                ?: JsonArray()
+        )
+        val history = parser.fromJson<List<DHistory>>(
+            mangaJson.get(Backup.HISTORY)
+                ?: JsonArray()
+        )
+        val tracks = parser.fromJson<List<TrackImpl>>(
+            mangaJson.get(Backup.TRACK)
+                ?: JsonArray()
+        )
+
+        val source = try {
+            getHttpSource(manga.source)
+        } catch (e: NullPointerException) {
+            null
+        }
+        val sourceName = sourceMapping[manga.source] ?: manga.source.toString()
+
+        logger.debug("Restoring Manga: ${manga.title} from $sourceName")
+
+        try {
+            if (source != null) {
+                restoreMangaData(manga, source, chapters, categories, history, tracks)
+            } else {
+                errors.add(Date() to "${manga.title} [$sourceName]: Source not found: $sourceName (${manga.source})")
+            }
+        } catch (e: Exception) {
+            errors.add(Date() to "${manga.title} [$sourceName]: ${e.message}")
+        }
+    }
+
+    /**
+     * @param manga manga data from json
+     * @param source source to get manga data from
+     * @param chapters chapters data from json
+     * @param categories categories data from json
+     * @param history history data from json
+     * @param tracks tracking data from json
+     */
+    private suspend fun restoreMangaData(
+        manga: Manga,
+        source: Source,
+        chapters: List<Chapter>,
+        categories: List<String>,
+        history: List<DHistory>,
+        tracks: List<Track>
+    ) {
+        fetchManga(source, manga)
+
+//        updateChapters(source, fetchedManga, chapters)
+
+//        backupManager.restoreCategoriesForManga(manga, categories)
+
+//        backupManager.restoreHistoryForManga(history)
+
+//        backupManager.restoreTrackForManga(manga, tracks)
+
+//        updateTracking(fetchedManga, tracks)
+    }
+
+    /**
+     * Fetches manga information
+     *
+     * @param source source of manga
+     * @param manga manga that needs updating
+     * @return Updated manga.
+     */
+    private suspend fun fetchManga(source: Source, manga: Manga): SManga {
+        transaction {
+            if (MangaTable.select { (MangaTable.url eq manga.url) and (MangaTable.sourceReference eq manga.source) }.firstOrNull() == null) {
+                MangaTable.insert {
+                    it[url] = manga.url
+                    it[title] = manga.title
+
+                    it[sourceReference] = manga.source
+                }
+            }
+            MangaTable.update({ (MangaTable.url eq manga.url) and (MangaTable.sourceReference eq manga.source) }) {
+                it[MangaTable.inLibrary] = true
+            }
+        }
+
+        val fetchedManga = source.fetchMangaDetails(manga).awaitSingle()
+
+        transaction {
+            MangaTable.update({ (MangaTable.url eq manga.url) and (MangaTable.sourceReference eq manga.source) }) {
+
+                it[artist] = fetchedManga.artist
+                it[author] = fetchedManga.author
+                it[description] = fetchedManga.description
+                it[genre] = fetchedManga.genre
+                it[status] = fetchedManga.status
+                if (fetchedManga.thumbnail_url != null && fetchedManga.thumbnail_url!!.isNotEmpty())
+                    it[MangaTable.thumbnail_url] = fetchedManga.thumbnail_url
+            }
+        }
+
+        return fetchedManga
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/legacy/LegacyBackupValidator.kt

@@ -0,0 +1,71 @@
+package ir.armor.tachidesk.impl.backup.legacy
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 com.google.gson.JsonObject
+import ir.armor.tachidesk.impl.backup.legacy.models.Backup
+import ir.armor.tachidesk.model.database.SourceTable
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.transactions.transaction
+
+object LegacyBackupRestoreValidator {
+    data class ValidationResult(val missingSources: List<String>, val missingTrackers: List<String>)
+
+    /**
+     * Checks for critical backup file data.
+     *
+     * @throws Exception if version or manga cannot be found.
+     * @return List of missing sources or missing trackers.
+     */
+    fun validate(json: JsonObject): ValidationResult {
+        val version = json.get(Backup.VERSION)
+        val mangasJson = json.get(Backup.MANGAS)
+        if (version == null || mangasJson == null) {
+            throw Exception("File is missing data.")
+        }
+
+        val mangas = mangasJson.asJsonArray
+        if (mangas.size() == 0) {
+            throw Exception("Backup does not contain any manga.")
+        }
+
+        val sources = getSourceMapping(json)
+        val missingSources = transaction {
+            sources
+                .filter { SourceTable.select { SourceTable.id eq it.key }.firstOrNull() == null }
+                .map { "${it.value} (${it.key})" }
+                .sorted()
+        }
+
+        val trackers = mangas
+            .filter { it.asJsonObject.has("track") }
+            .flatMap { it.asJsonObject["track"].asJsonArray }
+            .map { it.asJsonObject["s"].asInt }
+            .distinct()
+
+        val missingTrackers = listOf("")
+//        val missingTrackers = trackers
+//                .mapNotNull { trackManager.getService(it) }
+//                .filter { !it.isLogged }
+//                .map { context.getString(it.nameRes()) }
+//                .sorted()
+
+        return ValidationResult(missingSources, missingTrackers)
+    }
+
+    fun getSourceMapping(json: JsonObject): Map<Long, String> {
+        val extensionsMapping = json.get(Backup.EXTENSIONS) ?: return emptyMap()
+
+        return extensionsMapping.asJsonArray
+            .map {
+                val items = it.asString.split(":")
+                items[0].toLong() to items[1]
+            }
+            .toMap()
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/legacy/models/Backup.kt

@@ -0,0 +1,25 @@
+package ir.armor.tachidesk.impl.backup.legacy.models
+
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+/**
+ * Json values
+ */
+object Backup {
+    const val CURRENT_VERSION = 2
+    const val MANGA = "manga"
+    const val MANGAS = "mangas"
+    const val TRACK = "track"
+    const val CHAPTERS = "chapters"
+    const val CATEGORIES = "categories"
+    const val EXTENSIONS = "extensions"
+    const val HISTORY = "history"
+    const val VERSION = "version"
+
+    fun getDefaultFilename(): String {
+        val date = SimpleDateFormat("yyyy-MM-dd_HH-mm", Locale.getDefault()).format(Date())
+        return "tachiyomi_$date.json"
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/legacy/models/DHistory.kt

@@ -0,0 +1,3 @@
+package ir.armor.tachidesk.impl.backup.legacy.models
+
+data class DHistory(val url: String, val lastRead: Long)

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/legacy/serializer/CategoryTypeAdapter.kt

@@ -0,0 +1,31 @@
+package ir.armor.tachidesk.impl.backup.legacy.serializer
+
+import com.github.salomonbrys.kotson.typeAdapter
+import com.google.gson.TypeAdapter
+import ir.armor.tachidesk.impl.backup.models.CategoryImpl
+
+/**
+ * JSON Serializer used to write / read [CategoryImpl] to / from json
+ */
+object CategoryTypeAdapter {
+
+    fun build(): TypeAdapter<CategoryImpl> {
+        return typeAdapter {
+            write {
+                beginArray()
+                value(it.name)
+                value(it.order)
+                endArray()
+            }
+
+            read {
+                beginArray()
+                val category = CategoryImpl()
+                category.name = nextString()
+                category.order = nextInt()
+                endArray()
+                category
+            }
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/legacy/serializer/ChapterTypeAdapter.kt

@@ -0,0 +1,59 @@
+package ir.armor.tachidesk.impl.backup.legacy.serializer
+
+import com.github.salomonbrys.kotson.typeAdapter
+import com.google.gson.TypeAdapter
+import com.google.gson.stream.JsonToken
+import ir.armor.tachidesk.impl.backup.models.ChapterImpl
+
+/**
+ * JSON Serializer used to write / read [ChapterImpl] to / from json
+ */
+object ChapterTypeAdapter {
+
+    private const val URL = "u"
+    private const val READ = "r"
+    private const val BOOKMARK = "b"
+    private const val LAST_READ = "l"
+
+    fun build(): TypeAdapter<ChapterImpl> {
+        return typeAdapter {
+            write {
+                if (it.read || it.bookmark || it.last_page_read != 0) {
+                    beginObject()
+                    name(URL)
+                    value(it.url)
+                    if (it.read) {
+                        name(READ)
+                        value(1)
+                    }
+                    if (it.bookmark) {
+                        name(BOOKMARK)
+                        value(1)
+                    }
+                    if (it.last_page_read != 0) {
+                        name(LAST_READ)
+                        value(it.last_page_read)
+                    }
+                    endObject()
+                }
+            }
+
+            read {
+                val chapter = ChapterImpl()
+                beginObject()
+                while (hasNext()) {
+                    if (peek() == JsonToken.NAME) {
+                        when (nextName()) {
+                            URL -> chapter.url = nextString()
+                            READ -> chapter.read = nextInt() == 1
+                            BOOKMARK -> chapter.bookmark = nextInt() == 1
+                            LAST_READ -> chapter.last_page_read = nextInt()
+                        }
+                    }
+                }
+                endObject()
+                chapter
+            }
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/legacy/serializer/HistoryTypeAdapter.kt

@@ -0,0 +1,32 @@
+package ir.armor.tachidesk.impl.backup.legacy.serializer
+
+import com.github.salomonbrys.kotson.typeAdapter
+import com.google.gson.TypeAdapter
+import ir.armor.tachidesk.impl.backup.legacy.models.DHistory
+
+/**
+ * JSON Serializer used to write / read [DHistory] to / from json
+ */
+object HistoryTypeAdapter {
+
+    fun build(): TypeAdapter<DHistory> {
+        return typeAdapter {
+            write {
+                if (it.lastRead != 0L) {
+                    beginArray()
+                    value(it.url)
+                    value(it.lastRead)
+                    endArray()
+                }
+            }
+
+            read {
+                beginArray()
+                val url = nextString()
+                val lastRead = nextLong()
+                endArray()
+                DHistory(url, lastRead)
+            }
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/legacy/serializer/MangaTypeAdapter.kt

@@ -0,0 +1,37 @@
+package ir.armor.tachidesk.impl.backup.legacy.serializer
+
+import com.github.salomonbrys.kotson.typeAdapter
+import com.google.gson.TypeAdapter
+import ir.armor.tachidesk.impl.backup.models.MangaImpl
+
+/**
+ * JSON Serializer used to write / read [MangaImpl] to / from json
+ */
+object MangaTypeAdapter {
+
+    fun build(): TypeAdapter<MangaImpl> {
+        return typeAdapter {
+            write {
+                beginArray()
+                value(it.url)
+                value(it.title)
+                value(it.source)
+                value(it.viewer)
+                value(it.chapter_flags)
+                endArray()
+            }
+
+            read {
+                beginArray()
+                val manga = MangaImpl()
+                manga.url = nextString()
+                manga.title = nextString()
+                manga.source = nextLong()
+                manga.viewer = nextInt()
+                manga.chapter_flags = nextInt()
+                endArray()
+                manga
+            }
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/legacy/serializer/TrackTypeAdapter.kt

@@ -0,0 +1,59 @@
+package ir.armor.tachidesk.impl.backup.legacy.serializer
+
+import com.github.salomonbrys.kotson.typeAdapter
+import com.google.gson.TypeAdapter
+import com.google.gson.stream.JsonToken
+import ir.armor.tachidesk.impl.backup.models.TrackImpl
+
+/**
+ * JSON Serializer used to write / read [TrackImpl] to / from json
+ */
+object TrackTypeAdapter {
+
+    private const val SYNC = "s"
+    private const val MEDIA = "r"
+    private const val LIBRARY = "ml"
+    private const val TITLE = "t"
+    private const val LAST_READ = "l"
+    private const val TRACKING_URL = "u"
+
+    fun build(): TypeAdapter<TrackImpl> {
+        return typeAdapter {
+            write {
+                beginObject()
+                name(TITLE)
+                value(it.title)
+                name(SYNC)
+                value(it.sync_id)
+                name(MEDIA)
+                value(it.media_id)
+                name(LIBRARY)
+                value(it.library_id)
+                name(LAST_READ)
+                value(it.last_chapter_read)
+                name(TRACKING_URL)
+                value(it.tracking_url)
+                endObject()
+            }
+
+            read {
+                val track = TrackImpl()
+                beginObject()
+                while (hasNext()) {
+                    if (peek() == JsonToken.NAME) {
+                        when (nextName()) {
+                            TITLE -> track.title = nextString()
+                            SYNC -> track.sync_id = nextInt()
+                            MEDIA -> track.media_id = nextInt()
+                            LIBRARY -> track.library_id = nextLong()
+                            LAST_READ -> track.last_chapter_read = nextInt()
+                            TRACKING_URL -> track.tracking_url = nextString()
+                        }
+                    }
+                }
+                endObject()
+                track
+            }
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/Category.kt

@@ -0,0 +1,23 @@
+package ir.armor.tachidesk.impl.backup.models
+
+import java.io.Serializable
+
+interface Category : Serializable {
+
+    var id: Int?
+
+    var name: String
+
+    var order: Int
+
+    var flags: Int
+
+    companion object {
+
+        fun create(name: String): Category = CategoryImpl().apply {
+            this.name = name
+        }
+
+        fun createDefault(): Category = create("Default").apply { id = 0 }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/CategoryImpl.kt

@@ -0,0 +1,24 @@
+package ir.armor.tachidesk.impl.backup.models
+
+class CategoryImpl : Category {
+
+    override var id: Int? = null
+
+    override lateinit var name: String
+
+    override var order: Int = 0
+
+    override var flags: Int = 0
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || javaClass != other.javaClass) return false
+
+        val category = other as Category
+        return name == category.name
+    }
+
+    override fun hashCode(): Int {
+        return name.hashCode()
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/Chapter.kt

@@ -0,0 +1,31 @@
+package ir.armor.tachidesk.impl.backup.models
+
+import eu.kanade.tachiyomi.source.model.SChapter
+import java.io.Serializable
+
+interface Chapter : SChapter, Serializable {
+
+    var id: Long?
+
+    var manga_id: Long?
+
+    var read: Boolean
+
+    var bookmark: Boolean
+
+    var last_page_read: Int
+
+    var date_fetch: Long
+
+    var source_order: Int
+
+    val isRecognizedNumber: Boolean
+        get() = chapter_number >= 0f
+
+    companion object {
+
+        fun create(): Chapter = ChapterImpl().apply {
+            chapter_number = -1f
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/ChapterImpl.kt

@@ -0,0 +1,53 @@
+package ir.armor.tachidesk.impl.backup.models
+
+import org.jetbrains.exposed.sql.ResultRow
+
+class ChapterImpl : Chapter {
+
+    override var id: Long? = null
+
+    override var manga_id: Long? = null
+
+    override lateinit var url: String
+
+    override lateinit var name: String
+
+    override var scanlator: String? = null
+
+    override var read: Boolean = false
+
+    override var bookmark: Boolean = false
+
+    override var last_page_read: Int = 0
+
+    override var date_fetch: Long = 0
+
+    override var date_upload: Long = 0
+
+    override var chapter_number: Float = 0f
+
+    override var source_order: Int = 0
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || javaClass != other.javaClass) return false
+
+        val chapter = other as Chapter
+        if (url != chapter.url) return false
+        return id == chapter.id
+    }
+
+    override fun hashCode(): Int {
+        return url.hashCode() + id.hashCode()
+    }
+
+    // Tachidesk -->
+    companion object {
+        fun fromQuery(chapterRecord: ResultRow): ChapterImpl {
+            return ChapterImpl().apply {
+                // TODO
+            }
+        }
+    }
+    // Tachidesk <--
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/History.kt

@@ -0,0 +1,42 @@
+package ir.armor.tachidesk.impl.backup.models
+
+import java.io.Serializable
+
+/**
+ * Object containing the history statistics of a chapter
+ */
+interface History : Serializable {
+
+    /**
+     * Id of history object.
+     */
+    var id: Long?
+
+    /**
+     * Chapter id of history object.
+     */
+    var chapter_id: Long
+
+    /**
+     * Last time chapter was read in time long format
+     */
+    var last_read: Long
+
+    /**
+     * Total time chapter was read - todo not yet implemented
+     */
+    var time_read: Long
+
+    companion object {
+
+        /**
+         * History constructor
+         *
+         * @param chapter chapter object
+         * @return history object
+         */
+        fun create(chapter: Chapter): History = HistoryImpl().apply {
+            this.chapter_id = chapter.id!!
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/HistoryImpl.kt

@@ -0,0 +1,27 @@
+package ir.armor.tachidesk.impl.backup.models
+
+/**
+ * Object containing the history statistics of a chapter
+ */
+class HistoryImpl : History {
+
+    /**
+     * Id of history object.
+     */
+    override var id: Long? = null
+
+    /**
+     * Chapter id of history object.
+     */
+    override var chapter_id: Long = 0
+
+    /**
+     * Last time chapter was read in time long format
+     */
+    override var last_read: Long = 0
+
+    /**
+     * Total time chapter was read - todo not yet implemented
+     */
+    override var time_read: Long = 0
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/LibraryManga.kt

@@ -0,0 +1,8 @@
+package ir.armor.tachidesk.impl.backup.models
+
+class LibraryManga : MangaImpl() {
+
+    var unread: Int = 0
+
+    var category: Int = 0
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/Manga.kt

@@ -0,0 +1,115 @@
+package ir.armor.tachidesk.impl.backup.models
+
+import eu.kanade.tachiyomi.source.model.SManga
+// import tachiyomi.source.model.MangaInfo
+
+interface Manga : SManga {
+
+    var id: Long?
+
+    var source: Long
+
+    /** is in library */
+    var favorite: Boolean
+
+    var last_update: Long
+
+    var date_added: Long
+
+    var viewer: Int
+
+    var chapter_flags: Int
+
+    var cover_last_modified: Long
+
+    fun setChapterOrder(order: Int) {
+        setFlags(order, SORT_MASK)
+    }
+
+    fun sortDescending(): Boolean {
+        return chapter_flags and SORT_MASK == SORT_DESC
+    }
+
+    fun getGenres(): List<String>? {
+        return genre?.split(", ")?.map { it.trim() }
+    }
+
+    private fun setFlags(flag: Int, mask: Int) {
+        chapter_flags = chapter_flags and mask.inv() or (flag and mask)
+    }
+
+    // Used to display the chapter's title one way or another
+    var displayMode: Int
+        get() = chapter_flags and DISPLAY_MASK
+        set(mode) = setFlags(mode, DISPLAY_MASK)
+
+    var readFilter: Int
+        get() = chapter_flags and READ_MASK
+        set(filter) = setFlags(filter, READ_MASK)
+
+    var downloadedFilter: Int
+        get() = chapter_flags and DOWNLOADED_MASK
+        set(filter) = setFlags(filter, DOWNLOADED_MASK)
+
+    var bookmarkedFilter: Int
+        get() = chapter_flags and BOOKMARKED_MASK
+        set(filter) = setFlags(filter, BOOKMARKED_MASK)
+
+    var sorting: Int
+        get() = chapter_flags and SORTING_MASK
+        set(sort) = setFlags(sort, SORTING_MASK)
+
+    companion object {
+
+        const val SORT_DESC = 0x00000000
+        const val SORT_ASC = 0x00000001
+        const val SORT_MASK = 0x00000001
+
+        // Generic filter that does not filter anything
+        const val SHOW_ALL = 0x00000000
+
+        const val SHOW_UNREAD = 0x00000002
+        const val SHOW_READ = 0x00000004
+        const val READ_MASK = 0x00000006
+
+        const val SHOW_DOWNLOADED = 0x00000008
+        const val SHOW_NOT_DOWNLOADED = 0x00000010
+        const val DOWNLOADED_MASK = 0x00000018
+
+        const val SHOW_BOOKMARKED = 0x00000020
+        const val SHOW_NOT_BOOKMARKED = 0x00000040
+        const val BOOKMARKED_MASK = 0x00000060
+
+        const val SORTING_SOURCE = 0x00000000
+        const val SORTING_NUMBER = 0x00000100
+        const val SORTING_UPLOAD_DATE = 0x00000200
+        const val SORTING_MASK = 0x00000300
+
+        const val DISPLAY_NAME = 0x00000000
+        const val DISPLAY_NUMBER = 0x00100000
+        const val DISPLAY_MASK = 0x00100000
+
+        fun create(source: Long): Manga = MangaImpl().apply {
+            this.source = source
+        }
+
+        fun create(pathUrl: String, title: String, source: Long = 0): Manga = MangaImpl().apply {
+            url = pathUrl
+            this.title = title
+            this.source = source
+        }
+    }
+}
+
+// fun Manga.toMangaInfo(): MangaInfo {
+//    return MangaInfo(
+//        artist = this.artist ?: "",
+//        author = this.author ?: "",
+//        cover = this.thumbnail_url ?: "",
+//        description = this.description ?: "",
+//        genres = this.getGenres() ?: emptyList(),
+//        key = this.url,
+//        status = this.status,
+//        title = this.title
+//    )
+// }

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/MangaCategory.kt

@@ -0,0 +1,20 @@
+package ir.armor.tachidesk.impl.backup.models
+
+class MangaCategory {
+
+    var id: Long? = null
+
+    var manga_id: Long = 0
+
+    var category_id: Int = 0
+
+    companion object {
+
+        fun create(manga: Manga, category: Category): MangaCategory {
+            val mc = MangaCategory()
+            mc.manga_id = manga.id!!
+            mc.category_id = category.id!!
+            return mc
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/MangaChapter.kt

@@ -0,0 +1,3 @@
+package ir.armor.tachidesk.impl.backup.models
+
+class MangaChapter(val manga: Manga, val chapter: Chapter)

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/MangaChapterHistory.kt

@@ -0,0 +1,10 @@
+package ir.armor.tachidesk.impl.backup.models
+
+/**
+ * Object containing manga, chapter and history
+ *
+ * @param manga object containing manga
+ * @param chapter object containing chater
+ * @param history object containing history
+ */
+data class MangaChapterHistory(val manga: Manga, val chapter: Chapter, val history: History)

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/MangaImpl.kt

@@ -0,0 +1,79 @@
+package ir.armor.tachidesk.impl.backup.models
+
+import ir.armor.tachidesk.model.database.MangaTable
+import org.jetbrains.exposed.sql.ResultRow
+
+open class MangaImpl : Manga {
+
+    override var id: Long? = 0
+
+    override var source: Long = -1
+
+    override lateinit var url: String
+
+    override lateinit var title: String
+
+    override var artist: String? = null
+
+    override var author: String? = null
+
+    override var description: String? = null
+
+    override var genre: String? = null
+
+    override var status: Int = 0
+
+    override var thumbnail_url: String? = null
+
+    override var favorite: Boolean = false
+
+    override var last_update: Long = 0
+
+    override var date_added: Long = 0
+
+    override var initialized: Boolean = false
+
+    /** Reader mode value
+     * ref: https://github.com/tachiyomiorg/tachiyomi/blob/ff369010074b058bb734ce24c66508300e6e9ac6/app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting/ReadingModeType.kt#L8
+     * 0 -> Default
+     * 1 -> Left to Right
+     * 2 -> Right to Left
+     * 3 -> Vertical
+     * 4 -> Webtoon
+     * 5 -> Continues Vertical
+     */
+    override var viewer: Int = 0
+
+    /** Contains some useful info about
+     */
+    override var chapter_flags: Int = 0
+
+    override var cover_last_modified: Long = 0
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || javaClass != other.javaClass) return false
+
+        val manga = other as Manga
+        if (url != manga.url) return false
+        return id == manga.id
+    }
+
+    override fun hashCode(): Int {
+        return url.hashCode() + id.hashCode()
+    }
+
+    // Tachidesk -->
+    companion object {
+        fun fromQuery(mangaRecord: ResultRow): MangaImpl {
+            return MangaImpl().apply {
+                url = mangaRecord[MangaTable.url]
+                title = mangaRecord[MangaTable.title]
+                source = mangaRecord[MangaTable.sourceReference]
+                viewer = 0 // TODO: implement
+                chapter_flags = 0 // TODO: implement
+            }
+        }
+    }
+    // Tachidesk <--
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/Track.kt

@@ -0,0 +1,46 @@
+package ir.armor.tachidesk.impl.backup.models
+
+import java.io.Serializable
+
+interface Track : Serializable {
+
+    var id: Long?
+
+    var manga_id: Long
+
+    var sync_id: Int
+
+    var media_id: Int
+
+    var library_id: Long?
+
+    var title: String
+
+    var last_chapter_read: Int
+
+    var total_chapters: Int
+
+    var score: Float
+
+    var status: Int
+
+    var started_reading_date: Long
+
+    var finished_reading_date: Long
+
+    var tracking_url: String
+
+    fun copyPersonalFrom(other: Track) {
+        last_chapter_read = other.last_chapter_read
+        score = other.score
+        status = other.status
+        started_reading_date = other.started_reading_date
+        finished_reading_date = other.finished_reading_date
+    }
+
+    companion object {
+        fun create(serviceId: Int): Track = TrackImpl().apply {
+            sync_id = serviceId
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/backup/models/TrackImpl.kt

@@ -0,0 +1,48 @@
+package ir.armor.tachidesk.impl.backup.models
+
+class TrackImpl : Track {
+
+    override var id: Long? = null
+
+    override var manga_id: Long = 0
+
+    override var sync_id: Int = 0
+
+    override var media_id: Int = 0
+
+    override var library_id: Long? = null
+
+    override lateinit var title: String
+
+    override var last_chapter_read: Int = 0
+
+    override var total_chapters: Int = 0
+
+    override var score: Float = 0f
+
+    override var status: Int = 0
+
+    override var started_reading_date: Long = 0
+
+    override var finished_reading_date: Long = 0
+
+    override var tracking_url: String = ""
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || javaClass != other.javaClass) return false
+
+        other as Track
+
+        if (manga_id != other.manga_id) return false
+        if (sync_id != other.sync_id) return false
+        return media_id == other.media_id
+    }
+
+    override fun hashCode(): Int {
+        var result = (manga_id xor manga_id.ushr(32)).toInt()
+        result = 31 * result + sync_id
+        result = 31 * result + media_id
+        return result
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/util/APKExtractor.kt

@@ -1,510 +0,0 @@
-package ir.armor.tachidesk.impl.util
-
-/*
-* Copyright (C) Contributors to the Suwayomi project
-*
-* This Source Code Form is subject to the terms of the Mozilla Public
-* 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.w3c.dom.Document
-import org.xml.sax.InputSource
-import java.io.IOException
-import java.io.StringReader
-import java.nio.file.Files
-import java.nio.file.Paths
-import java.util.zip.ZipFile
-import javax.xml.parsers.DocumentBuilderFactory
-
-object APKExtractor {
-    // decompressXML -- Parse the 'compressed' binary form of Android XML docs
-    // such as for AndroidManifest.xml in .apk files
-    var endDocTag = 0x00100101
-    var startTag = 0x00100102
-    var endTag = 0x00100103
-    fun prt(str: String?) {
-        // System.err.print(str);
-    }
-
-    fun decompressXML(xml: ByteArray): String {
-        val finalXML = StringBuilder()
-
-        // Compressed XML file/bytes starts with 24x bytes of data,
-        // 9 32 bit words in little endian order (LSB first):
-        // 0th word is 03 00 08 00
-        // 3rd word SEEMS TO BE: Offset at then of StringTable
-        // 4th word is: Number of strings in string table
-        // WARNING: Sometime I indiscriminently display or refer to word in
-        // little endian storage format, or in integer format (ie MSB first).
-        val numbStrings = LEW(xml, 4 * 4)
-
-        // StringIndexTable starts at offset 24x, an array of 32 bit LE offsets
-        // of the length/string data in the StringTable.
-        val sitOff = 0x24 // Offset of start of StringIndexTable
-
-        // StringTable, each string is represented with a 16 bit little endian
-        // character count, followed by that number of 16 bit (LE) (Unicode)
-        // chars.
-        val stOff = sitOff + numbStrings * 4 // StringTable follows
-        // StrIndexTable
-
-        // XMLTags, The XML tag tree starts after some unknown content after the
-        // StringTable. There is some unknown data after the StringTable, scan
-        // forward from this point to the flag for the start of an XML start
-        // tag.
-        var xmlTagOff = LEW(xml, 3 * 4) // Start from the offset in the 3rd
-        // word.
-        // Scan forward until we find the bytes: 0x02011000(x00100102 in normal
-        // int)
-        var ii = xmlTagOff
-        while (ii < xml.size - 4) {
-            if (LEW(xml, ii) == startTag) {
-                xmlTagOff = ii
-                break
-            }
-            ii += 4
-        }
-
-        // XML tags and attributes:
-        // Every XML start and end tag consists of 6 32 bit words:
-        // 0th word: 02011000 for startTag and 03011000 for endTag
-        // 1st word: a flag?, like 38000000
-        // 2nd word: Line of where this tag appeared in the original source file
-        // 3rd word: FFFFFFFF ??
-        // 4th word: StringIndex of NameSpace name, or FFFFFFFF for default NS
-        // 5th word: StringIndex of Element Name
-        // (Note: 01011000 in 0th word means end of XML document, endDocTag)
-
-        // Start tags (not end tags) contain 3 more words:
-        // 6th word: 14001400 meaning??
-        // 7th word: Number of Attributes that follow this tag(follow word 8th)
-        // 8th word: 00000000 meaning??
-
-        // Attributes consist of 5 words:
-        // 0th word: StringIndex of Attribute Name's Namespace, or FFFFFFFF
-        // 1st word: StringIndex of Attribute Name
-        // 2nd word: StringIndex of Attribute Value, or FFFFFFF if ResourceId
-        // used
-        // 3rd word: Flags?
-        // 4th word: str ind of attr value again, or ResourceId of value
-
-        // TMP, dump string table to tr for debugging
-        // tr.addSelect("strings", null);
-        // for (int ii=0; ii<numbStrings; ii++) {
-        // // Length of string starts at StringTable plus offset in StrIndTable
-        // String str = compXmlString(xml, sitOff, stOff, ii);
-        // tr.add(String.valueOf(ii), str);
-        // }
-        // tr.parent();
-
-        // Step through the XML tree element tags and attributes
-        var off = xmlTagOff
-        var indent = 0
-        var startTagLineNo = -2
-        while (off < xml.size) {
-            val tag0 = LEW(xml, off)
-            // int tag1 = LEW(xml, off+1*4);
-            val lineNo = LEW(xml, off + 2 * 4)
-            // int tag3 = LEW(xml, off+3*4);
-            val nameNsSi = LEW(xml, off + 4 * 4)
-            val nameSi = LEW(xml, off + 5 * 4)
-            if (tag0 == startTag) { // XML START TAG
-                val tag6 = LEW(xml, off + 6 * 4) // Expected to be 14001400
-                val numbAttrs = LEW(xml, off + 7 * 4) // Number of Attributes
-                // to follow
-                // int tag8 = LEW(xml, off+8*4); // Expected to be 00000000
-                off += 9 * 4 // Skip over 6+3 words of startTag data
-                val name = compXmlString(xml, sitOff, stOff, nameSi)
-                // tr.addSelect(name, null);
-                startTagLineNo = lineNo
-
-                // Look for the Attributes
-                val sb = StringBuffer()
-                for (ii in 0 until numbAttrs) {
-                    val attrNameNsSi = LEW(xml, off) // AttrName Namespace Str
-                    // Ind, or FFFFFFFF
-                    val attrNameSi = LEW(xml, off + 1 * 4) // AttrName String
-                    // Index
-                    val attrValueSi = LEW(xml, off + 2 * 4) // AttrValue Str
-                    // Ind, or
-                    // FFFFFFFF
-                    val attrFlags = LEW(xml, off + 3 * 4)
-                    val attrResId = LEW(xml, off + 4 * 4) // AttrValue
-                    // ResourceId or dup
-                    // AttrValue StrInd
-                    off += 5 * 4 // Skip over the 5 words of an attribute
-                    val attrName = compXmlString(
-                        xml, sitOff, stOff,
-                        attrNameSi
-                    )
-                    val attrValue = if (attrValueSi != -1) compXmlString(xml, sitOff, stOff, attrValueSi)
-                    else "resourceID 0x ${Integer.toHexString(attrResId)}"
-                    sb.append(" $attrName=\"$attrValue\"")
-                    // tr.add(attrName, attrValue);
-                }
-                finalXML.append("<$name$sb>")
-                prtIndent(indent, "<$name$sb>")
-                indent++
-            } else if (tag0 == endTag) { // XML END TAG
-                indent--
-                off += 6 * 4 // Skip over 6 words of endTag data
-                val name = compXmlString(xml, sitOff, stOff, nameSi)
-                finalXML.append("</$name>")
-                prtIndent(
-                    indent,
-                    "</" + name + "> (line " + startTagLineNo +
-                        "-" + lineNo + ")"
-                )
-                // tr.parent(); // Step back up the NobTree
-            } else if (tag0 == endDocTag) { // END OF XML DOC TAG
-                break
-            } else {
-                prt(
-                    "  Unrecognized tag code '" + Integer.toHexString(tag0) +
-                        "' at offset " + off
-                )
-                break
-            }
-        } // end of while loop scanning tags and attributes of XML tree
-        // prt("    end at offset " + off);
-        return finalXML.toString()
-    } // end of decompressXML
-
-    fun compXmlString(xml: ByteArray, sitOff: Int, stOff: Int, strInd: Int): String? {
-        if (strInd < 0) return null
-        val strOff = stOff + LEW(xml, sitOff + strInd * 4)
-        return compXmlStringAt(xml, strOff)
-    }
-
-    var spaces = "                                             "
-    fun prtIndent(indent: Int, str: String) {
-        prt(spaces.substring(0, Math.min(indent * 2, spaces.length)) + str)
-    }
-
-    // compXmlStringAt -- Return the string stored in StringTable format at
-    // offset strOff. This offset points to the 16 bit string length, which
-    // is followed by that number of 16 bit (Unicode) chars.
-    fun compXmlStringAt(arr: ByteArray, strOff: Int): String {
-        val strLen: Int = arr[strOff + 1].toInt() shl 8 and 0xff00 or arr[strOff].toInt() and 0xff
-        val chars = ByteArray(strLen)
-        for (ii in 0 until strLen) {
-            chars[ii] = arr[strOff + 2 + ii * 2]
-        }
-        return String(chars) // Hack, just use 8 byte chars
-    } // end of compXmlStringAt
-
-    // LEW -- Return value of a Little Endian 32 bit word from the byte array
-    // at offset off.
-    fun LEW(arr: ByteArray, off: Int): Int {
-
-        return (arr[off + 3].toInt() shl 24) and -0x1000000 or
-            (arr[off + 2].toInt() shl 16 and 0xff0000) or
-            (arr[off + 1].toInt() shl 8 and 0xff00) or
-            (arr[off].toInt() and 0xFF)
-    } // end of LEW
-
-    @Throws(Exception::class)
-    fun loadXMLFromString(xml: String?): Document {
-        val docBuilderFactory = DocumentBuilderFactory.newInstance()
-        val docBuilder = docBuilderFactory.newDocumentBuilder()
-        return docBuilder.parse(InputSource(StringReader(xml)))
-    }
-
-    @Throws(IOException::class)
-    fun extract_dex_and_read_className(filePath: String?, dexPath: String?): String {
-        var zip: ZipFile? = null
-        zip = ZipFile(filePath)
-        val androidManifest = zip.getEntry("AndroidManifest.xml")
-        val classesDex = zip.getEntry("classes.dex")
-
-        // write dex file
-        val dexStream = zip.getInputStream(classesDex)
-        Files.newOutputStream(Paths.get(dexPath)).use { os ->
-            val buffer = ByteArray(1024)
-            var len: Int
-            while (dexStream.read(buffer).also { len = it } > 0) {
-                os.write(buffer, 0, len)
-            }
-        }
-
-        // read xml file
-        val `is` = zip.getInputStream(androidManifest)
-        val buf = ByteArray(1024000) // 100 kb
-        `is`.read(buf)
-        `is`.close()
-        zip.close()
-        val xml = decompressXML(buf)
-        try {
-            val xmlDoc = loadXMLFromString(xml)
-            val pkg = xmlDoc.documentElement.getAttribute("package")
-            val nodes = xmlDoc.getElementsByTagName("meta-data")
-            for (i in 0 until nodes.length) {
-                val attributes = nodes.item(i).attributes
-                println(attributes.getNamedItem("name").nodeValue)
-                if (attributes.getNamedItem("name").nodeValue == "tachiyomi.extension.class") return pkg + attributes.getNamedItem("value").nodeValue
-            }
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
-        return ""
-    }
-}
-
-// original Java code
-
-// package ir.armor.tachidesk.impl.util;
-//
-// /*
-// * Copyright (C) Contributors to the Suwayomi project
-// *
-// * This Source Code Form is subject to the terms of the Mozilla Public
-// * 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.w3c.dom.Document;
-// import org.w3c.dom.NamedNodeMap;
-// import org.w3c.dom.NodeList;
-// import org.xml.sax.InputSource;
-//
-// import javax.xml.parsers.DocumentBuilder;
-// import javax.xml.parsers.DocumentBuilderFactory;
-// import java.io.*;
-// import java.nio.file.Files;
-// import java.nio.file.Paths;
-// import java.util.zip.ZipEntry;
-// import java.util.zip.ZipFile;
-//
-// public class APKExtractor {
-//    // decompressXML -- Parse the 'compressed' binary form of Android XML docs
-//    // such as for AndroidManifest.xml in .apk files
-//    public static int endDocTag = 0x00100101;
-//    public static int startTag = 0x00100102;
-//    public static int endTag = 0x00100103;
-//
-//    static void prt(String str) {
-//        //System.err.print(str);
-//    }
-//
-//    public static String decompressXML(byte[] xml) {
-//
-//        StringBuilder finalXML = new StringBuilder();
-//
-//        // Compressed XML file/bytes starts with 24x bytes of data,
-//        // 9 32 bit words in little endian order (LSB first):
-//        // 0th word is 03 00 08 00
-//        // 3rd word SEEMS TO BE: Offset at then of StringTable
-//        // 4th word is: Number of strings in string table
-//        // WARNING: Sometime I indiscriminently display or refer to word in
-//        // little endian storage format, or in integer format (ie MSB first).
-//        int numbStrings = LEW(xml, 4 * 4);
-//
-//        // StringIndexTable starts at offset 24x, an array of 32 bit LE offsets
-//        // of the length/string data in the StringTable.
-//        int sitOff = 0x24; // Offset of start of StringIndexTable
-//
-//        // StringTable, each string is represented with a 16 bit little endian
-//        // character count, followed by that number of 16 bit (LE) (Unicode)
-//        // chars.
-//        int stOff = sitOff + numbStrings * 4; // StringTable follows
-//        // StrIndexTable
-//
-//        // XMLTags, The XML tag tree starts after some unknown content after the
-//        // StringTable. There is some unknown data after the StringTable, scan
-//        // forward from this point to the flag for the start of an XML start
-//        // tag.
-//        int xmlTagOff = LEW(xml, 3 * 4); // Start from the offset in the 3rd
-//        // word.
-//        // Scan forward until we find the bytes: 0x02011000(x00100102 in normal
-//        // int)
-//        for (int ii = xmlTagOff; ii < xml.length - 4; ii += 4) {
-//            if (LEW(xml, ii) == startTag) {
-//                xmlTagOff = ii;
-//                break;
-//            }
-//        } // end of hack, scanning for start of first start tag
-//
-//        // XML tags and attributes:
-//        // Every XML start and end tag consists of 6 32 bit words:
-//        // 0th word: 02011000 for startTag and 03011000 for endTag
-//        // 1st word: a flag?, like 38000000
-//        // 2nd word: Line of where this tag appeared in the original source file
-//        // 3rd word: FFFFFFFF ??
-//        // 4th word: StringIndex of NameSpace name, or FFFFFFFF for default NS
-//        // 5th word: StringIndex of Element Name
-//        // (Note: 01011000 in 0th word means end of XML document, endDocTag)
-//
-//        // Start tags (not end tags) contain 3 more words:
-//        // 6th word: 14001400 meaning??
-//        // 7th word: Number of Attributes that follow this tag(follow word 8th)
-//        // 8th word: 00000000 meaning??
-//
-//        // Attributes consist of 5 words:
-//        // 0th word: StringIndex of Attribute Name's Namespace, or FFFFFFFF
-//        // 1st word: StringIndex of Attribute Name
-//        // 2nd word: StringIndex of Attribute Value, or FFFFFFF if ResourceId
-//        // used
-//        // 3rd word: Flags?
-//        // 4th word: str ind of attr value again, or ResourceId of value
-//
-//        // TMP, dump string table to tr for debugging
-//        // tr.addSelect("strings", null);
-//        // for (int ii=0; ii<numbStrings; ii++) {
-//        // // Length of string starts at StringTable plus offset in StrIndTable
-//        // String str = compXmlString(xml, sitOff, stOff, ii);
-//        // tr.add(String.valueOf(ii), str);
-//        // }
-//        // tr.parent();
-//
-//        // Step through the XML tree element tags and attributes
-//        int off = xmlTagOff;
-//        int indent = 0;
-//        int startTagLineNo = -2;
-//        while (off < xml.length) {
-//            int tag0 = LEW(xml, off);
-//            // int tag1 = LEW(xml, off+1*4);
-//            int lineNo = LEW(xml, off + 2 * 4);
-//            // int tag3 = LEW(xml, off+3*4);
-//            int nameNsSi = LEW(xml, off + 4 * 4);
-//            int nameSi = LEW(xml, off + 5 * 4);
-//
-//            if (tag0 == startTag) { // XML START TAG
-//                int tag6 = LEW(xml, off + 6 * 4); // Expected to be 14001400
-//                int numbAttrs = LEW(xml, off + 7 * 4); // Number of Attributes
-//                // to follow
-//                // int tag8 = LEW(xml, off+8*4); // Expected to be 00000000
-//                off += 9 * 4; // Skip over 6+3 words of startTag data
-//                String name = compXmlString(xml, sitOff, stOff, nameSi);
-//                // tr.addSelect(name, null);
-//                startTagLineNo = lineNo;
-//
-//                // Look for the Attributes
-//                StringBuffer sb = new StringBuffer();
-//                for (int ii = 0; ii < numbAttrs; ii++) {
-//                    int attrNameNsSi = LEW(xml, off); // AttrName Namespace Str
-//                    // Ind, or FFFFFFFF
-//                    int attrNameSi = LEW(xml, off + 1 * 4); // AttrName String
-//                    // Index
-//                    int attrValueSi = LEW(xml, off + 2 * 4); // AttrValue Str
-//                    // Ind, or
-//                    // FFFFFFFF
-//                    int attrFlags = LEW(xml, off + 3 * 4);
-//                    int attrResId = LEW(xml, off + 4 * 4); // AttrValue
-//                    // ResourceId or dup
-//                    // AttrValue StrInd
-//                    off += 5 * 4; // Skip over the 5 words of an attribute
-//
-//                    String attrName = compXmlString(xml, sitOff, stOff,
-//                            attrNameSi);
-//                    String attrValue = attrValueSi != -1 ? compXmlString(xml,
-//                            sitOff, stOff, attrValueSi) : "resourceID 0x"
-//                            + Integer.toHexString(attrResId);
-//                    sb.append(" " + attrName + "=\"" + attrValue + "\"");
-//                    // tr.add(attrName, attrValue);
-//                }
-//                finalXML.append("<" + name + sb + ">");
-//                prtIndent(indent, "<" + name + sb + ">");
-//                indent++;
-//
-//            } else if (tag0 == endTag) { // XML END TAG
-//                indent--;
-//                off += 6 * 4; // Skip over 6 words of endTag data
-//                String name = compXmlString(xml, sitOff, stOff, nameSi);
-//                finalXML.append("</" + name + ">");
-//                prtIndent(indent, "</" + name + "> (line " + startTagLineNo
-//                        + "-" + lineNo + ")");
-//                // tr.parent(); // Step back up the NobTree
-//
-//            } else if (tag0 == endDocTag) { // END OF XML DOC TAG
-//                break;
-//
-//            } else {
-//                prt("  Unrecognized tag code '" + Integer.toHexString(tag0)
-//                        + "' at offset " + off);
-//                break;
-//            }
-//        } // end of while loop scanning tags and attributes of XML tree
-//        //prt("    end at offset " + off);
-//        return finalXML.toString();
-//    } // end of decompressXML
-//
-//    public static String compXmlString(byte[] xml, int sitOff, int stOff, int strInd) {
-//        if (strInd < 0)
-//            return null;
-//        int strOff = stOff + LEW(xml, sitOff + strInd * 4);
-//        return compXmlStringAt(xml, strOff);
-//    }
-//
-//    public static String spaces = "                                             ";
-//
-//    public static void prtIndent(int indent, String str) {
-//        prt(spaces.substring(0, Math.min(indent * 2, spaces.length())) + str);
-//    }
-//
-//    // compXmlStringAt -- Return the string stored in StringTable format at
-//    // offset strOff. This offset points to the 16 bit string length, which
-//    // is followed by that number of 16 bit (Unicode) chars.
-//    public static String compXmlStringAt(byte[] arr, int strOff) {
-//        int strLen = arr[strOff + 1] << 8 & 0xff00 | arr[strOff] & 0xff;
-//        byte[] chars = new byte[strLen];
-//        for (int ii = 0; ii < strLen; ii++) {
-//            chars[ii] = arr[strOff + 2 + ii * 2];
-//        }
-//        return new String(chars); // Hack, just use 8 byte chars
-//    } // end of compXmlStringAt
-//
-//    // LEW -- Return value of a Little Endian 32 bit word from the byte array
-//    // at offset off.
-//    public static int LEW(byte[] arr, int off) {
-//        return ((arr[off + 3] << 24) & 0xff000000) |
-//                ((arr[off + 2] << 16) & 0xff0000) |
-//                ((arr[off + 1] << 8) & 0xff00) |
-//                (arr[off] & 0xFF);
-//    } // end of LEW
-//
-//    public static Document loadXMLFromString(String xml) throws Exception {
-//        DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
-//        DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
-//        return docBuilder.parse(new InputSource(new StringReader(xml)));
-//    }
-//
-//    public static String extract_dex_and_read_className(String filePath, String dexPath) throws IOException {
-//        ZipFile zip = null;
-//
-//        zip = new ZipFile(filePath);
-//        ZipEntry androidManifest = zip.getEntry("AndroidManifest.xml");
-//        ZipEntry classesDex = zip.getEntry("classes.dex");
-//
-//        // write dex file
-//        InputStream dexStream = zip.getInputStream(classesDex);
-//        try (OutputStream os = Files.newOutputStream(Paths.get(dexPath))) {
-//            byte[] buffer = new byte[1024];
-//            int len;
-//            while ((len = dexStream.read(buffer)) > 0) {
-//                os.write(buffer, 0, len);
-//            }
-//        }
-//
-//        // read xml file
-//        InputStream is = zip.getInputStream(androidManifest);
-//        byte[] buf = new byte[1024000]; // 100 kb
-//        is.read(buf);
-//        is.close();
-//        zip.close();
-//
-//        String xml = APKExtractor.decompressXML(buf);
-//        try {
-//            Document xmlDoc = loadXMLFromString(xml);
-//            String pkg = xmlDoc.getDocumentElement().getAttribute("package");
-//            NodeList nodes = xmlDoc.getElementsByTagName("meta-data");
-//            for (int i = 0; i < nodes.getLength(); i++) {
-//                NamedNodeMap attributes = nodes.item(i).getAttributes();
-//                System.out.println(attributes.getNamedItem("name").getNodeValue());
-//                if (attributes.getNamedItem("name").getNodeValue().equals("tachiyomi.extension.class"))
-//                    return pkg + attributes.getNamedItem("value").getNodeValue();
-//            }
-//        } catch (Exception e) {
-//            e.printStackTrace();
-//        }
-//        return "";
-//    }
-// }

server/src/main/kotlin/ir/armor/tachidesk/impl/util/CachedImageResponse.kt

@@ -0,0 +1,67 @@
+package ir.armor.tachidesk.impl.util
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 okhttp3.Response
+import okio.buffer
+import okio.sink
+import java.io.BufferedInputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.InputStream
+import java.nio.file.Files
+import java.nio.file.Paths
+
+object CachedImageResponse {
+    private fun pathToInputStream(path: String): InputStream {
+        return BufferedInputStream(FileInputStream(path))
+    }
+
+    private fun findFileNameStartingWith(directoryPath: String, fileName: String): String? {
+        File(directoryPath).listFiles().forEach { file ->
+            if (file.name.startsWith(fileName))
+                return "$directoryPath/${file.name}"
+        }
+        return null
+    }
+
+    /** fetch a cached image response, calls `fetcher` if cache fails */
+    suspend fun getCachedImageResponse(saveDir: String, fileName: String, fetcher: suspend () -> Response): Pair<InputStream, String> {
+        val cachedFile = findFileNameStartingWith(saveDir, fileName)
+        val filePath = "$saveDir/$fileName"
+        if (cachedFile != null) {
+            val fileType = cachedFile.substringAfter(filePath)
+            return Pair(
+                pathToInputStream(cachedFile),
+                "image/$fileType"
+            )
+        }
+
+        val response = fetcher()
+
+        if (response.code == 200) {
+            val contentType = response.headers["content-type"]!!
+            val fullPath = filePath + "." + contentType.substringAfter("image/")
+
+            Files.newOutputStream(Paths.get(fullPath)).use { output ->
+                response.body!!.source().use { input ->
+                    output.sink().buffer().use {
+                        it.writeAll(input)
+                        it.flush()
+                    }
+                }
+            }
+            return Pair(
+                pathToInputStream(fullPath),
+                contentType
+            )
+        } else {
+            throw Exception("request error! ${response.code}")
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/util/File.kt

@@ -1,85 +0,0 @@
-package ir.armor.tachidesk.impl
-
-/*
- * Copyright (C) Contributors to the Suwayomi project
- * 
- * This Source Code Form is subject to the terms of the Mozilla Public
- * 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 okhttp3.Response
-import okio.BufferedSource
-import okio.buffer
-import okio.sink
-import java.io.BufferedInputStream
-import java.io.File
-import java.io.FileInputStream
-import java.io.InputStream
-import java.io.OutputStream
-import java.nio.file.Files
-import java.nio.file.Paths
-
-// fun writeStream(fileStream: InputStream, path: String) {
-//    Files.newOutputStream(Paths.get(path)).use { os ->
-//        val buffer = ByteArray(128 * 1024)
-//        var len: Int
-//        while (fileStream.read(buffer).also { len = it } > 0) {
-//            os.write(buffer, 0, len)
-//        }
-//    }
-// }
-
-fun pathToInputStream(path: String): InputStream {
-    return BufferedInputStream(FileInputStream(path))
-}
-
-fun findFileNameStartingWith(directoryPath: String, fileName: String): String? {
-    File(directoryPath).listFiles().forEach { file ->
-        if (file.name.startsWith(fileName))
-            return "$directoryPath/${file.name}"
-    }
-    return null
-}
-
-/**
- * Saves the given source to an output stream and closes both resources.
- *
- * @param stream the stream where the source is copied.
- */
-private fun BufferedSource.saveTo(stream: OutputStream) {
-    use { input ->
-        stream.sink().buffer().use {
-            it.writeAll(input)
-            it.flush()
-        }
-    }
-}
-
-fun getCachedImageResponse(saveDir: String, fileName: String, fetcher: () -> Response): Pair<InputStream, String> {
-    val cachedFile = findFileNameStartingWith(saveDir, fileName)
-    val filePath = "$saveDir/$fileName"
-    if (cachedFile != null) {
-        val fileType = cachedFile.substringAfter(filePath)
-        return Pair(
-            pathToInputStream(cachedFile),
-            "image/$fileType"
-        )
-    }
-
-    val response = fetcher()
-
-    if (response.code == 200) {
-        val contentType = response.headers["content-type"]!!
-        val fullPath = filePath + "." + contentType.substringAfter("image/")
-
-        Files.newOutputStream(Paths.get(fullPath)).use { os ->
-            response.body!!.source().saveTo(os)
-        }
-        return Pair(
-            pathToInputStream(fullPath),
-            contentType
-        )
-    } else {
-        throw Exception("request error! ${response.code}")
-    }
-}

server/src/main/kotlin/ir/armor/tachidesk/impl/util/GetHttpSource.kt

@@ -0,0 +1,57 @@
+package ir.armor.tachidesk.impl.util
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 eu.kanade.tachiyomi.source.Source
+import eu.kanade.tachiyomi.source.SourceFactory
+import eu.kanade.tachiyomi.source.online.HttpSource
+import ir.armor.tachidesk.impl.util.PackageTools.loadExtensionSources
+import ir.armor.tachidesk.model.database.ExtensionTable
+import ir.armor.tachidesk.model.database.SourceTable
+import ir.armor.tachidesk.server.ApplicationDirs
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.kodein.di.DI
+import org.kodein.di.conf.global
+import org.kodein.di.instance
+import java.util.concurrent.ConcurrentHashMap
+
+object GetHttpSource {
+    private val sourceCache = ConcurrentHashMap<Long, HttpSource>()
+    private val applicationDirs by DI.global.instance<ApplicationDirs>()
+
+    fun getHttpSource(sourceId: Long): HttpSource {
+        val cachedResult: HttpSource? = sourceCache[sourceId]
+        if (cachedResult != null) {
+            return cachedResult
+        }
+
+        val sourceRecord = transaction {
+            SourceTable.select { SourceTable.id eq sourceId }.firstOrNull()!!
+        }
+
+        val extensionId = sourceRecord[SourceTable.extension]
+        val extensionRecord = transaction {
+            ExtensionTable.select { ExtensionTable.id eq extensionId }.firstOrNull()!!
+        }
+
+        val apkName = extensionRecord[ExtensionTable.apkName]
+        val className = extensionRecord[ExtensionTable.classFQName]
+        val jarName = apkName.substringBefore(".apk") + ".jar"
+        val jarPath = "${applicationDirs.extensionsRoot}/$jarName"
+
+        when (val instance = loadExtensionSources(jarPath, className)) {
+            is Source -> listOf(instance)
+            is SourceFactory -> instance.createSources()
+            else -> throw Exception("Unknown source class type! ${instance.javaClass}")
+        }.forEach {
+            sourceCache[it.id] = it as HttpSource
+        }
+        return sourceCache[sourceId]!!
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/util/MangaDexHelper.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.impl
+package ir.armor.tachidesk.impl.util
 
 /*
  * Copyright (C) Contributors to the Suwayomi project
@@ -13,6 +13,7 @@ import okhttp3.FormBody
 import okhttp3.OkHttpClient
 import java.net.URLEncoder
 
+// TODO: finish MangaDex support
 class MangaDexHelper(private val mangaDexSource: HttpSource) {
 
     private fun clientBuilder(): OkHttpClient = clientBuilder(0)

server/src/main/kotlin/ir/armor/tachidesk/impl/util/OkHttp.kt

@@ -0,0 +1,48 @@
+package ir.armor.tachidesk.impl.util
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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.coroutines.suspendCancellableCoroutine
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.Response
+import java.io.IOException
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+// Based on https://github.com/gildor/kotlin-coroutines-okhttp
+suspend fun Call.await(): Response {
+    return suspendCancellableCoroutine { continuation ->
+        enqueue(
+            object : Callback {
+                override fun onResponse(call: Call, response: Response) {
+                    if (!response.isSuccessful) {
+                        continuation.resumeWithException(Exception("HTTP error ${response.code}"))
+                        return
+                    }
+
+                    continuation.resume(response)
+                }
+
+                override fun onFailure(call: Call, e: IOException) {
+                    // Don't bother with resuming the continuation if it is already cancelled.
+                    if (continuation.isCancelled) return
+                    continuation.resumeWithException(e)
+                }
+            }
+        )
+
+        continuation.invokeOnCancellation {
+            try {
+                cancel()
+            } catch (ex: Throwable) {
+                // Ignore cancel exception
+            }
+        }
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/util/PackageTools.kt

@@ -0,0 +1,141 @@
+package ir.armor.tachidesk.impl.util
+
+import android.content.pm.PackageInfo
+import android.content.pm.Signature
+import android.os.Bundle
+import com.googlecode.d2j.dex.Dex2jar
+import com.googlecode.d2j.reader.MultiDexFileReader
+import com.googlecode.dex2jar.tools.BaksmaliBaseDexExceptionHandler
+import eu.kanade.tachiyomi.util.lang.Hash
+import ir.armor.tachidesk.server.ApplicationDirs
+import mu.KotlinLogging
+import net.dongliu.apk.parser.ApkFile
+import net.dongliu.apk.parser.ApkParsers
+import org.kodein.di.DI
+import org.kodein.di.conf.global
+import org.kodein.di.instance
+import org.w3c.dom.Element
+import org.w3c.dom.Node
+import xyz.nulldev.androidcompat.pm.InstalledPackage.Companion.toList
+import xyz.nulldev.androidcompat.pm.toPackageInfo
+import java.io.File
+import java.net.URL
+import java.net.URLClassLoader
+import java.nio.file.Files
+import java.nio.file.Path
+import javax.xml.parsers.DocumentBuilderFactory
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ * 
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+object PackageTools {
+    private val logger = KotlinLogging.logger {}
+    private val applicationDirs by DI.global.instance<ApplicationDirs>()
+
+    const val EXTENSION_FEATURE = "tachiyomi.extension"
+    const val METADATA_SOURCE_CLASS = "tachiyomi.extension.class"
+    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
+
+    private const val officialSignature = "7ce04da7773d41b489f4693a366c36bcd0a11fc39b547168553c285bd7348e23" // inorichi's key
+    private const val unofficialSignature = "64feb21075ba97ebc9cc981243645b331595c111cef1b0d084236a0403b00581" // ArMor's key
+    var trustedSignatures = mutableSetOf<String>() + officialSignature + unofficialSignature
+
+    /**
+     * Convert dex to jar, a wrapper for the dex2jar library
+     */
+    fun dex2jar(dexFile: String, jarFile: String, fileNameWithoutType: String) {
+        // adopted from com.googlecode.dex2jar.tools.Dex2jarCmd.doCommandLine
+        // source at: https://github.com/DexPatcher/dex2jar/tree/v2.1-20190905-lanchon/dex-tools/src/main/java/com/googlecode/dex2jar/tools/Dex2jarCmd.java
+
+        val jarFilePath = File(jarFile).toPath()
+        val reader = MultiDexFileReader.open(Files.readAllBytes(File(dexFile).toPath()))
+        val handler = BaksmaliBaseDexExceptionHandler()
+        Dex2jar
+            .from(reader)
+            .withExceptionHandler(handler)
+            .reUseReg(false)
+            .topoLogicalSort()
+            .skipDebug(true)
+            .optimizeSynchronized(false)
+            .printIR(false)
+            .noCode(false)
+            .skipExceptions(false)
+            .to(jarFilePath)
+        if (handler.hasException()) {
+            val errorFile: Path = File(applicationDirs.extensionsRoot).toPath().resolve("$fileNameWithoutType-error.txt")
+            logger.error(
+                "Detail Error Information in File $errorFile\n" +
+                    "Please report this file to one of following link if possible (any one).\n" +
+                    "    https://sourceforge.net/p/dex2jar/tickets/\n" +
+                    "    https://bitbucket.org/pxb1988/dex2jar/issues\n" +
+                    "    https://github.com/pxb1988/dex2jar/issues\n" +
+                    "    dex2jar@googlegroups.com"
+            )
+            handler.dump(errorFile, emptyArray<String>())
+        }
+    }
+
+    /** A modified version of `xyz.nulldev.androidcompat.pm.InstalledPackage.info` */
+    fun getPackageInfo(apkFilePath: String): PackageInfo {
+        val apk = File(apkFilePath)
+        return ApkParsers.getMetaInfo(apk).toPackageInfo(apk).apply {
+            val parsed = ApkFile(apk)
+            val dbFactory = DocumentBuilderFactory.newInstance()
+            val dBuilder = dbFactory.newDocumentBuilder()
+            val doc = parsed.manifestXml.byteInputStream().use {
+                dBuilder.parse(it)
+            }
+
+            logger.debug(parsed.manifestXml)
+
+            applicationInfo.metaData = Bundle().apply {
+                val appTag = doc.getElementsByTagName("application").item(0)
+
+                appTag?.childNodes?.toList()?.filter {
+                    it.nodeType == Node.ELEMENT_NODE
+                }?.map {
+                    it as Element
+                }?.filter {
+                    it.tagName == "meta-data"
+                }?.map {
+                    putString(
+                        it.attributes.getNamedItem("android:name").nodeValue,
+                        it.attributes.getNamedItem("android:value").nodeValue
+                    )
+                }
+            }
+
+            signatures = (
+                parsed.apkSingers.flatMap { it.certificateMetas }
+                /*+ parsed.apkV2Singers.flatMap { it.certificateMetas }*/
+                ) // Blocked by: https://github.com/hsiafan/apk-parser/issues/72
+                .map { Signature(it.data) }.toTypedArray()
+        }
+    }
+
+    fun getSignatureHash(pkgInfo: PackageInfo): String? {
+        val signatures = pkgInfo.signatures
+        return if (signatures != null && signatures.isNotEmpty()) {
+            Hash.sha256(signatures.first().toByteArray())
+        } else {
+            null
+        }
+    }
+
+    /**
+     * loads the extension main class called $className from the jar located at $jarPath
+     * It may return an instance of HttpSource or SourceFactory depending on the extension.
+     */
+    fun loadExtensionSources(jarPath: String, className: String): Any {
+        val classLoader = URLClassLoader(arrayOf<URL>(URL("file:$jarPath")))
+        val classToLoad = Class.forName(className, false, classLoader)
+        return classToLoad.getDeclaredConstructor().newInstance()
+    }
+}

server/src/main/kotlin/ir/armor/tachidesk/impl/util/RxCoroutineBridge.kt

@@ -0,0 +1,62 @@
+package ir.armor.tachidesk.impl.util
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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.coroutines.CancellableContinuation
+import kotlinx.coroutines.suspendCancellableCoroutine
+import rx.Observable
+import rx.Subscriber
+import rx.Subscription
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+// source: https://github.com/jobobby04/TachiyomiSY/blob/9320221a4e8b118ef68deb60d8c4c32bcbb9e06f/app/src/main/java/eu/kanade/tachiyomi/util/lang/RxCoroutineBridge.kt
+/*
+ * Util functions for bridging RxJava and coroutines. Taken from TachiyomiEH/SY.
+ */
+
+suspend fun <T> Observable<T>.awaitSingle(): T = single().awaitOne()
+
+private suspend fun <T> Observable<T>.awaitOne(): T = suspendCancellableCoroutine { cont ->
+    cont.unsubscribeOnCancellation(
+        subscribe(
+            object : Subscriber<T>() {
+                override fun onStart() {
+                    request(1)
+                }
+
+                override fun onNext(t: T) {
+                    cont.resume(t)
+                }
+
+                override fun onCompleted() {
+                    if (cont.isActive) cont.resumeWithException(
+                        IllegalStateException(
+                            "Should have invoked onNext"
+                        )
+                    )
+                }
+
+                override fun onError(e: Throwable) {
+                    /*
+                       * Rx1 observable throws NoSuchElementException if cancellation happened before
+                       * element emission. To mitigate this we try to atomically resume continuation with exception:
+                       * if resume failed, then we know that continuation successfully cancelled itself
+                       */
+                    val token = cont.tryResumeWithException(e)
+                    if (token != null) {
+                        cont.completeResume(token)
+                    }
+                }
+            }
+        )
+    )
+}
+
+private fun <T> CancellableContinuation<T>.unsubscribeOnCancellation(sub: Subscription) =
+    invokeOnCancellation { sub.unsubscribe() }

server/src/main/kotlin/ir/armor/tachidesk/model/database/CategoryMangaTable.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database.table
+package ir.armor.tachidesk.model.database
 
 /*
  * Copyright (C) Contributors to the Suwayomi project

server/src/main/kotlin/ir/armor/tachidesk/model/database/CategoryTable.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database.table
+package ir.armor.tachidesk.model.database
 
 /*
  * Copyright (C) Contributors to the Suwayomi project
@@ -7,7 +7,7 @@ package ir.armor.tachidesk.database.table
  * 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 ir.armor.tachidesk.database.dataclass.CategoryDataClass
+import ir.armor.tachidesk.model.dataclass.CategoryDataClass
 import org.jetbrains.exposed.dao.id.IntIdTable
 import org.jetbrains.exposed.sql.ResultRow
 

server/src/main/kotlin/ir/armor/tachidesk/model/database/ChapterTable.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database.table
+package ir.armor.tachidesk.model.database
 
 /*
  * Copyright (C) Contributors to the Suwayomi project

server/src/main/kotlin/ir/armor/tachidesk/model/database/ExtensionTable.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database.table
+package ir.armor.tachidesk.model.database
 
 /*
  * Copyright (C) Contributors to the Suwayomi project
@@ -10,15 +10,22 @@ package ir.armor.tachidesk.database.table
 import org.jetbrains.exposed.dao.id.IntIdTable
 
 object ExtensionTable : IntIdTable() {
+    val apkName = varchar("apk_name", 1024)
+
+    // default is the local source icon from tachiyomi
+    val iconUrl = varchar("icon_url", 2048)
+        .default("https://raw.githubusercontent.com/tachiyomiorg/tachiyomi/64ba127e7d43b1d7e6d58a6f5c9b2bd5fe0543f7/app/src/main/res/mipmap-xxxhdpi/ic_local_source.webp")
+
     val name = varchar("name", 128)
     val pkgName = varchar("pkg_name", 128)
     val versionName = varchar("version_name", 16)
     val versionCode = integer("version_code")
     val lang = varchar("lang", 10)
     val isNsfw = bool("is_nsfw")
-    val apkName = varchar("apk_name", 1024)
-    val iconUrl = varchar("icon_url", 2048)
 
-    val installed = bool("installed").default(false)
-    val classFQName = varchar("class_name", 256).default("") // fully qualified name
+    val isInstalled = bool("is_installed").default(false)
+    val hasUpdate = bool("has_update").default(false)
+    val isObsolete = bool("is_obsolete").default(false)
+
+    val classFQName = varchar("class_name", 1024).default("") // fully qualified name
 }

server/src/main/kotlin/ir/armor/tachidesk/model/database/MangaTable.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database.table
+package ir.armor.tachidesk.model.database
 
 /*
  * Copyright (C) Contributors to the Suwayomi project
@@ -8,8 +8,8 @@ package ir.armor.tachidesk.database.table
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 import eu.kanade.tachiyomi.source.model.SManga
-import ir.armor.tachidesk.database.dataclass.MangaDataClass
-import ir.armor.tachidesk.impl.proxyThumbnailUrl
+import ir.armor.tachidesk.impl.MangaList.proxyThumbnailUrl
+import ir.armor.tachidesk.model.dataclass.MangaDataClass
 import org.jetbrains.exposed.dao.id.IntIdTable
 import org.jetbrains.exposed.sql.ResultRow
 

server/src/main/kotlin/ir/armor/tachidesk/model/database/PageTable.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database.table
+package ir.armor.tachidesk.model.database
 
 /*
  * Copyright (C) Contributors to the Suwayomi project

server/src/main/kotlin/ir/armor/tachidesk/model/database/SourceTable.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database.table
+package ir.armor.tachidesk.model.database
 
 /*
  * Copyright (C) Contributors to the Suwayomi project
@@ -15,5 +15,4 @@ object SourceTable : IdTable<Long>() {
     val lang = varchar("lang", 10)
     val extension = reference("extension", ExtensionTable)
     val partOfFactorySource = bool("part_of_factory_source").default(false)
-    val positionInFactorySource = integer("position_in_factory_source").nullable()
 }

server/src/main/kotlin/ir/armor/tachidesk/model/dataclass/CategoryDataClass.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database.dataclass
+package ir.armor.tachidesk.model.dataclass
 
 /*
  * Copyright (C) Contributors to the Suwayomi project

server/src/main/kotlin/ir/armor/tachidesk/model/dataclass/ChapterDataClass.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database.dataclass
+package ir.armor.tachidesk.model.dataclass
 
 /*
  * Copyright (C) Contributors to the Suwayomi project
@@ -8,14 +8,19 @@ package ir.armor.tachidesk.database.dataclass
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 data class ChapterDataClass(
-    val id: Int,
     val url: String,
     val name: String,
     val date_upload: Long,
     val chapter_number: Float,
     val scanlator: String?,
     val mangaId: Int,
-    val chapterIndex: Int,
-    val chapterCount: Int,
+
+    /** this chapter's index */
+    val chapterIndex: Int? = null,
+
+    /** total chapter count, used to calculate if there's a next and prev chapter */
+    val chapterCount: Int? = null,
+
+    /** used to construct pages in the front-end */
     val pageCount: Int? = null,
 )

server/src/main/kotlin/ir/armor/tachidesk/model/dataclass/DBMangaer.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database
+package ir.armor.tachidesk.model.dataclass
 
 /*
  * Copyright (C) Contributors to the Suwayomi project
@@ -7,20 +7,24 @@ package ir.armor.tachidesk.database
  * 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 ir.armor.tachidesk.database.table.CategoryMangaTable
-import ir.armor.tachidesk.database.table.CategoryTable
-import ir.armor.tachidesk.database.table.ChapterTable
-import ir.armor.tachidesk.database.table.ExtensionTable
-import ir.armor.tachidesk.database.table.MangaTable
-import ir.armor.tachidesk.database.table.PageTable
-import ir.armor.tachidesk.database.table.SourceTable
-import ir.armor.tachidesk.server.applicationDirs
+import ir.armor.tachidesk.model.database.CategoryMangaTable
+import ir.armor.tachidesk.model.database.CategoryTable
+import ir.armor.tachidesk.model.database.ChapterTable
+import ir.armor.tachidesk.model.database.ExtensionTable
+import ir.armor.tachidesk.model.database.MangaTable
+import ir.armor.tachidesk.model.database.PageTable
+import ir.armor.tachidesk.model.database.SourceTable
+import ir.armor.tachidesk.server.ApplicationDirs
 import org.jetbrains.exposed.sql.Database
 import org.jetbrains.exposed.sql.SchemaUtils
 import org.jetbrains.exposed.sql.transactions.transaction
+import org.kodein.di.DI
+import org.kodein.di.conf.global
+import org.kodein.di.instance
 
 object DBMangaer {
     val db by lazy {
+        val applicationDirs by DI.global.instance<ApplicationDirs>()
         Database.connect("jdbc:h2:${applicationDirs.dataRoot}/database", "org.h2.Driver")
     }
 }

server/src/main/kotlin/ir/armor/tachidesk/model/dataclass/ExtensionDataClass.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database.dataclass
+package ir.armor.tachidesk.model.dataclass
 
 /*
  * Copyright (C) Contributors to the Suwayomi project
@@ -8,14 +8,17 @@ package ir.armor.tachidesk.database.dataclass
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 data class ExtensionDataClass(
+    val apkName: String,
+    val iconUrl: String,
+
     val name: String,
     val pkgName: String,
     val versionName: String,
     val versionCode: Int,
     val lang: String,
     val isNsfw: Boolean,
-    val apkName: String,
-    val iconUrl: String,
+
     val installed: Boolean,
-    val classFQName: String,
+    val hasUpdate: Boolean,
+    val obsolete: Boolean,
 )

server/src/main/kotlin/ir/armor/tachidesk/model/dataclass/MangaDataClass.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database.dataclass
+package ir.armor.tachidesk.model.dataclass
 
 /*
  * Copyright (C) Contributors to the Suwayomi project
@@ -7,7 +7,7 @@ package ir.armor.tachidesk.database.dataclass
  * 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 ir.armor.tachidesk.database.table.MangaStatus
+import ir.armor.tachidesk.model.database.MangaStatus
 
 data class MangaDataClass(
     val id: Int,

server/src/main/kotlin/ir/armor/tachidesk/model/dataclass/PageDataClass.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database.dataclass
+package ir.armor.tachidesk.model.dataclass
 
 /*
  * Copyright (C) Contributors to the Suwayomi project

server/src/main/kotlin/ir/armor/tachidesk/model/dataclass/SourceDataClass.kt

@@ -1,4 +1,4 @@
-package ir.armor.tachidesk.database.dataclass
+package ir.armor.tachidesk.model.dataclass
 
 /*
  * Copyright (C) Contributors to the Suwayomi project

server/src/main/kotlin/ir/armor/tachidesk/server/JavalinSetup.kt

@@ -2,35 +2,47 @@ package ir.armor.tachidesk.server
 
 import io.javalin.Javalin
 import ir.armor.tachidesk.Main
-import ir.armor.tachidesk.impl.addMangaToCategory
-import ir.armor.tachidesk.impl.addMangaToLibrary
-import ir.armor.tachidesk.impl.createCategory
-import ir.armor.tachidesk.impl.getCategoryList
-import ir.armor.tachidesk.impl.getCategoryMangaList
-import ir.armor.tachidesk.impl.getChapter
-import ir.armor.tachidesk.impl.getChapterList
-import ir.armor.tachidesk.impl.getExtensionIcon
-import ir.armor.tachidesk.impl.getExtensionList
-import ir.armor.tachidesk.impl.getLibraryMangas
-import ir.armor.tachidesk.impl.getManga
-import ir.armor.tachidesk.impl.getMangaCategories
-import ir.armor.tachidesk.impl.getMangaList
-import ir.armor.tachidesk.impl.getPageImage
-import ir.armor.tachidesk.impl.getSource
-import ir.armor.tachidesk.impl.getSourceList
-import ir.armor.tachidesk.impl.getThumbnail
-import ir.armor.tachidesk.impl.installAPK
-import ir.armor.tachidesk.impl.removeCategory
-import ir.armor.tachidesk.impl.removeExtension
-import ir.armor.tachidesk.impl.removeMangaFromCategory
-import ir.armor.tachidesk.impl.removeMangaFromLibrary
-import ir.armor.tachidesk.impl.reorderCategory
-import ir.armor.tachidesk.impl.sourceFilters
-import ir.armor.tachidesk.impl.sourceGlobalSearch
-import ir.armor.tachidesk.impl.sourceSearch
-import ir.armor.tachidesk.impl.updateCategory
+import ir.armor.tachidesk.impl.Category.createCategory
+import ir.armor.tachidesk.impl.Category.getCategoryList
+import ir.armor.tachidesk.impl.Category.removeCategory
+import ir.armor.tachidesk.impl.Category.reorderCategory
+import ir.armor.tachidesk.impl.Category.updateCategory
+import ir.armor.tachidesk.impl.CategoryManga.addMangaToCategory
+import ir.armor.tachidesk.impl.CategoryManga.getCategoryMangaList
+import ir.armor.tachidesk.impl.CategoryManga.getMangaCategories
+import ir.armor.tachidesk.impl.CategoryManga.removeMangaFromCategory
+import ir.armor.tachidesk.impl.Chapter.getChapter
+import ir.armor.tachidesk.impl.Chapter.getChapterList
+import ir.armor.tachidesk.impl.Extension.getExtensionIcon
+import ir.armor.tachidesk.impl.Extension.installExtension
+import ir.armor.tachidesk.impl.Extension.uninstallExtension
+import ir.armor.tachidesk.impl.Extension.updateExtension
+import ir.armor.tachidesk.impl.ExtensionsList.getExtensionList
+import ir.armor.tachidesk.impl.Library.addMangaToLibrary
+import ir.armor.tachidesk.impl.Library.getLibraryMangas
+import ir.armor.tachidesk.impl.Library.removeMangaFromLibrary
+import ir.armor.tachidesk.impl.Manga.getManga
+import ir.armor.tachidesk.impl.Manga.getMangaThumbnail
+import ir.armor.tachidesk.impl.MangaList.getMangaList
+import ir.armor.tachidesk.impl.Page.getPageImage
+import ir.armor.tachidesk.impl.Search.sourceFilters
+import ir.armor.tachidesk.impl.Search.sourceGlobalSearch
+import ir.armor.tachidesk.impl.Search.sourceSearch
+import ir.armor.tachidesk.impl.Source.getSource
+import ir.armor.tachidesk.impl.Source.getSourceList
+import ir.armor.tachidesk.impl.backup.BackupFlags
+import ir.armor.tachidesk.impl.backup.legacy.LegacyBackupExport.createLegacyBackup
+import ir.armor.tachidesk.impl.backup.legacy.LegacyBackupImport.restoreLegacyBackup
 import ir.armor.tachidesk.server.util.openInBrowser
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.future.future
 import mu.KotlinLogging
+import java.io.IOException
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.concurrent.CompletableFuture
 
 /*
  * Copyright (C) Contributors to the Suwayomi project
@@ -39,222 +51,339 @@ import mu.KotlinLogging
  * 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/. */
 
-private val logger = KotlinLogging.logger {}
+object JavalinSetup {
+    private val logger = KotlinLogging.logger {}
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
 
-fun javalinSetup() {
-    var hasWebUiBundled = false
+    private fun <T> future(block: suspend CoroutineScope.() -> T): CompletableFuture<T> {
+        return scope.future(block = block)
+    }
 
-    val app = Javalin.create { config ->
-        try {
-            Main::class.java.getResource("/react/index.html")
-            hasWebUiBundled = true
-            config.addStaticFiles("/react")
-            config.addSinglePageRoot("/", "/react/index.html")
-        } catch (e: RuntimeException) {
-            logger.warn("react build files are missing.")
-            hasWebUiBundled = false
+    fun javalinSetup() {
+        var hasWebUiBundled = false
+
+        val app = Javalin.create { config ->
+            try {
+                Main::class.java.getResource("/react/index.html")
+                hasWebUiBundled = true
+                config.addStaticFiles("/react")
+                config.addSinglePageRoot("/", "/react/index.html")
+            } catch (e: RuntimeException) {
+                logger.warn("react build files are missing.")
+                hasWebUiBundled = false
+            }
+            config.enableCorsForAllOrigins()
+        }.start(serverConfig.ip, serverConfig.port)
+        if (hasWebUiBundled && serverConfig.initialOpenInBrowserEnabled) {
+            openInBrowser()
         }
-        config.enableCorsForAllOrigins()
-    }.start(serverConfig.ip, serverConfig.port)
-    if (hasWebUiBundled && serverConfig.initialOpenInBrowserEnabled) {
-        openInBrowser()
-    }
 
-    app.exception(NullPointerException::class.java) { e, ctx ->
-        logger.error("NullPointerException while handling the request", e)
-        ctx.status(404)
-    }
+        app.exception(NullPointerException::class.java) { e, ctx ->
+            logger.error("NullPointerException while handling the request", e)
+            ctx.status(404)
+        }
 
-    app.get("/api/v1/extension/list") { ctx ->
-        ctx.json(getExtensionList())
-    }
+        app.exception(IOException::class.java) { e, ctx ->
+            logger.error("IOException while handling the request", e)
+            ctx.status(500)
+            ctx.result(e.message ?: "Internal Server Error")
+        }
 
-    app.get("/api/v1/extension/install/:apkName") { ctx ->
-        val apkName = ctx.pathParam("apkName")
+        app.get("/api/v1/extension/list") { ctx ->
+            ctx.json(
+                future {
+                    getExtensionList()
+                }
+            )
+        }
 
-        ctx.status(
-            installAPK(apkName)
-        )
-    }
+        app.get("/api/v1/extension/install/:pkgName") { ctx ->
+            val pkgName = ctx.pathParam("pkgName")
 
-    app.get("/api/v1/extension/uninstall/:apkName") { ctx ->
-        val apkName = ctx.pathParam("apkName")
+            ctx.json(
+                future {
+                    installExtension(pkgName)
+                }
+            )
+        }
 
-        removeExtension(apkName)
-        ctx.status(200)
-    }
+        app.get("/api/v1/extension/update/:pkgName") { ctx ->
+            val pkgName = ctx.pathParam("pkgName")
 
-    // icon for extension named `apkName`
-    app.get("/api/v1/extension/icon/:apkName") { ctx ->
-        val apkName = ctx.pathParam("apkName")
-        val result = getExtensionIcon(apkName)
+            ctx.json(
+                future {
+                    updateExtension(pkgName)
+                }
+            )
+        }
 
-        ctx.result(result.first)
-        ctx.header("content-type", result.second)
-    }
+        app.get("/api/v1/extension/uninstall/:pkgName") { ctx ->
+            val pkgName = ctx.pathParam("pkgName")
 
-    // list of sources
-    app.get("/api/v1/source/list") { ctx ->
-        ctx.json(getSourceList())
-    }
+            uninstallExtension(pkgName)
+            ctx.status(200)
+        }
 
-    // fetch source with id `sourceId`
-    app.get("/api/v1/source/:sourceId") { ctx ->
-        val sourceId = ctx.pathParam("sourceId").toLong()
-        ctx.json(getSource(sourceId))
-    }
+        // icon for extension named `apkName`
+        app.get("/api/v1/extension/icon/:apkName") { ctx ->
+            val apkName = ctx.pathParam("apkName")
 
-    // popular mangas from source with id `sourceId`
-    app.get("/api/v1/source/:sourceId/popular/:pageNum") { ctx ->
-        val sourceId = ctx.pathParam("sourceId").toLong()
-        val pageNum = ctx.pathParam("pageNum").toInt()
-        ctx.json(getMangaList(sourceId, pageNum, popular = true))
-    }
+            ctx.result(
+                future { getExtensionIcon(apkName) }
+                    .thenApply {
+                        ctx.header("content-type", it.second)
+                        it.first
+                    }
+            )
+        }
 
-    // latest mangas from source with id `sourceId`
-    app.get("/api/v1/source/:sourceId/latest/:pageNum") { ctx ->
-        val sourceId = ctx.pathParam("sourceId").toLong()
-        val pageNum = ctx.pathParam("pageNum").toInt()
-        ctx.json(getMangaList(sourceId, pageNum, popular = false))
-    }
+        // list of sources
+        app.get("/api/v1/source/list") { ctx ->
+            ctx.json(getSourceList())
+        }
 
-    // get manga info
-    app.get("/api/v1/manga/:mangaId/") { ctx ->
-        val mangaId = ctx.pathParam("mangaId").toInt()
-        ctx.json(getManga(mangaId))
-    }
+        // fetch source with id `sourceId`
+        app.get("/api/v1/source/:sourceId") { ctx ->
+            val sourceId = ctx.pathParam("sourceId").toLong()
+            ctx.json(getSource(sourceId))
+        }
 
-    // manga thumbnail
-    app.get("api/v1/manga/:mangaId/thumbnail") { ctx ->
-        val mangaId = ctx.pathParam("mangaId").toInt()
-        val result = getThumbnail(mangaId)
+        // popular mangas from source with id `sourceId`
+        app.get("/api/v1/source/:sourceId/popular/:pageNum") { ctx ->
+            val sourceId = ctx.pathParam("sourceId").toLong()
+            val pageNum = ctx.pathParam("pageNum").toInt()
+            ctx.json(
+                future {
+                    getMangaList(sourceId, pageNum, popular = true)
+                }
+            )
+        }
 
-        ctx.result(result.first)
-        ctx.header("content-type", result.second)
-    }
+        // latest mangas from source with id `sourceId`
+        app.get("/api/v1/source/:sourceId/latest/:pageNum") { ctx ->
+            val sourceId = ctx.pathParam("sourceId").toLong()
+            val pageNum = ctx.pathParam("pageNum").toInt()
+            ctx.json(
+                future {
+                    getMangaList(sourceId, pageNum, popular = false)
+                }
+            )
+        }
 
-    // adds the manga to library
-    app.get("api/v1/manga/:mangaId/library") { ctx ->
-        val mangaId = ctx.pathParam("mangaId").toInt()
-        addMangaToLibrary(mangaId)
-        ctx.status(200)
-    }
+        // get manga info
+        app.get("/api/v1/manga/:mangaId/") { ctx ->
+            val mangaId = ctx.pathParam("mangaId").toInt()
+            ctx.json(
+                future {
+                    getManga(mangaId)
+                }
+            )
+        }
 
-    // removes the manga from the library
-    app.delete("api/v1/manga/:mangaId/library") { ctx ->
-        val mangaId = ctx.pathParam("mangaId").toInt()
-        removeMangaFromLibrary(mangaId)
-        ctx.status(200)
-    }
+        // manga thumbnail
+        app.get("api/v1/manga/:mangaId/thumbnail") { ctx ->
+            val mangaId = ctx.pathParam("mangaId").toInt()
 
-    // list manga's categories
-    app.get("api/v1/manga/:mangaId/category/") { ctx ->
-        val mangaId = ctx.pathParam("mangaId").toInt()
-        ctx.json(getMangaCategories(mangaId))
-    }
+            ctx.result(
+                future { getMangaThumbnail(mangaId) }
+                    .thenApply {
+                        ctx.header("content-type", it.second)
+                        it.first
+                    }
+            )
+        }
 
-    // adds the manga to category
-    app.get("api/v1/manga/:mangaId/category/:categoryId") { ctx ->
-        val mangaId = ctx.pathParam("mangaId").toInt()
-        val categoryId = ctx.pathParam("categoryId").toInt()
-        addMangaToCategory(mangaId, categoryId)
-        ctx.status(200)
-    }
+        // adds the manga to library
+        app.get("api/v1/manga/:mangaId/library") { ctx ->
+            val mangaId = ctx.pathParam("mangaId").toInt()
 
-    // removes the manga from the category
-    app.delete("api/v1/manga/:mangaId/category/:categoryId") { ctx ->
-        val mangaId = ctx.pathParam("mangaId").toInt()
-        val categoryId = ctx.pathParam("categoryId").toInt()
-        removeMangaFromCategory(mangaId, categoryId)
-        ctx.status(200)
-    }
+            ctx.result(
+                future { addMangaToLibrary(mangaId) }
+            )
+        }
 
-    app.get("/api/v1/manga/:mangaId/chapters") { ctx ->
-        val mangaId = ctx.pathParam("mangaId").toInt()
-        ctx.json(getChapterList(mangaId))
-    }
+        // removes the manga from the library
+        app.delete("api/v1/manga/:mangaId/library") { ctx ->
+            val mangaId = ctx.pathParam("mangaId").toInt()
 
-    app.get("/api/v1/manga/:mangaId/chapter/:chapterIndex") { ctx ->
-        val chapterIndex = ctx.pathParam("chapterIndex").toInt()
-        val mangaId = ctx.pathParam("mangaId").toInt()
-        ctx.json(getChapter(chapterIndex, mangaId))
-    }
+            ctx.result(
+                future { removeMangaFromLibrary(mangaId) }
+            )
+        }
 
-    app.get("/api/v1/manga/:mangaId/chapter/:chapterIndex/page/:index") { ctx ->
-        val mangaId = ctx.pathParam("mangaId").toInt()
-        val chapterIndex = ctx.pathParam("chapterIndex").toInt()
-        val index = ctx.pathParam("index").toInt()
-        val result = getPageImage(mangaId, chapterIndex, index)
+        // list manga's categories
+        app.get("api/v1/manga/:mangaId/category/") { ctx ->
+            val mangaId = ctx.pathParam("mangaId").toInt()
+            ctx.json(getMangaCategories(mangaId))
+        }
 
-        ctx.result(result.first)
-        ctx.header("content-type", result.second)
-    }
+        // adds the manga to category
+        app.get("api/v1/manga/:mangaId/category/:categoryId") { ctx ->
+            val mangaId = ctx.pathParam("mangaId").toInt()
+            val categoryId = ctx.pathParam("categoryId").toInt()
+            addMangaToCategory(mangaId, categoryId)
+            ctx.status(200)
+        }
 
-    // global search
-    app.get("/api/v1/search/:searchTerm") { ctx ->
-        val searchTerm = ctx.pathParam("searchTerm")
-        ctx.json(sourceGlobalSearch(searchTerm))
-    }
+        // removes the manga from the category
+        app.delete("api/v1/manga/:mangaId/category/:categoryId") { ctx ->
+            val mangaId = ctx.pathParam("mangaId").toInt()
+            val categoryId = ctx.pathParam("categoryId").toInt()
+            removeMangaFromCategory(mangaId, categoryId)
+            ctx.status(200)
+        }
 
-    // single source search
-    app.get("/api/v1/source/:sourceId/search/:searchTerm/:pageNum") { ctx ->
-        val sourceId = ctx.pathParam("sourceId").toLong()
-        val searchTerm = ctx.pathParam("searchTerm")
-        val pageNum = ctx.pathParam("pageNum").toInt()
-        ctx.json(sourceSearch(sourceId, searchTerm, pageNum))
-    }
+        // get chapter list when showing a manga
+        app.get("/api/v1/manga/:mangaId/chapters") { ctx ->
+            val mangaId = ctx.pathParam("mangaId").toInt()
+            ctx.json(future { getChapterList(mangaId) })
+        }
 
-    // source filter list
-    app.get("/api/v1/source/:sourceId/filters/") { ctx ->
-        val sourceId = ctx.pathParam("sourceId").toLong()
-        ctx.json(sourceFilters(sourceId))
-    }
+        // used to display a chapter, get a chapter in order to show it's pages
+        app.get("/api/v1/manga/:mangaId/chapter/:chapterIndex") { ctx ->
+            val chapterIndex = ctx.pathParam("chapterIndex").toInt()
+            val mangaId = ctx.pathParam("mangaId").toInt()
+            ctx.json(future { getChapter(chapterIndex, mangaId) })
+        }
 
-    // lists mangas that have no category assigned
-    app.get("/api/v1/library/") { ctx ->
-        ctx.json(getLibraryMangas())
-    }
+        app.get("/api/v1/manga/:mangaId/chapter/:chapterIndex/page/:index") { ctx ->
+            val mangaId = ctx.pathParam("mangaId").toInt()
+            val chapterIndex = ctx.pathParam("chapterIndex").toInt()
+            val index = ctx.pathParam("index").toInt()
 
-    // category list
-    app.get("/api/v1/category/") { ctx ->
-        ctx.json(getCategoryList())
-    }
+            ctx.result(
+                future { getPageImage(mangaId, chapterIndex, index) }
+                    .thenApply {
+                        ctx.header("content-type", it.second)
+                        it.first
+                    }
+            )
+        }
 
-    // category create
-    app.post("/api/v1/category/") { ctx ->
-        val name = ctx.formParam("name")!!
-        createCategory(name)
-        ctx.status(200)
-    }
+        // global search
+        app.get("/api/v1/search/:searchTerm") { ctx ->
+            val searchTerm = ctx.pathParam("searchTerm")
+            ctx.json(sourceGlobalSearch(searchTerm))
+        }
 
-    // category modification
-    app.patch("/api/v1/category/:categoryId") { ctx ->
-        val categoryId = ctx.pathParam("categoryId").toInt()
-        val name = ctx.formParam("name")
-        val isLanding = if (ctx.formParam("isLanding") != null) ctx.formParam("isLanding")?.toBoolean() else null
-        updateCategory(categoryId, name, isLanding)
-        ctx.status(200)
-    }
+        // single source search
+        app.get("/api/v1/source/:sourceId/search/:searchTerm/:pageNum") { ctx ->
+            val sourceId = ctx.pathParam("sourceId").toLong()
+            val searchTerm = ctx.pathParam("searchTerm")
+            val pageNum = ctx.pathParam("pageNum").toInt()
+            ctx.json(future { sourceSearch(sourceId, searchTerm, pageNum) })
+        }
 
-    // category re-ordering
-    app.patch("/api/v1/category/:categoryId/reorder") { ctx ->
-        val categoryId = ctx.pathParam("categoryId").toInt()
-        val from = ctx.formParam("from")!!.toInt()
-        val to = ctx.formParam("to")!!.toInt()
-        reorderCategory(categoryId, from, to)
-        ctx.status(200)
-    }
+        // source filter list
+        app.get("/api/v1/source/:sourceId/filters/") { ctx ->
+            val sourceId = ctx.pathParam("sourceId").toLong()
+            ctx.json(sourceFilters(sourceId))
+        }
 
-    // category delete
-    app.delete("/api/v1/category/:categoryId") { ctx ->
-        val categoryId = ctx.pathParam("categoryId").toInt()
-        removeCategory(categoryId)
-        ctx.status(200)
-    }
+        // lists mangas that have no category assigned
+        app.get("/api/v1/library/") { ctx ->
+            ctx.json(getLibraryMangas())
+        }
 
-    // returns the manga list associated with a category
-    app.get("/api/v1/category/:categoryId") { ctx ->
-        val categoryId = ctx.pathParam("categoryId").toInt()
-        ctx.json(getCategoryMangaList(categoryId))
+        // category list
+        app.get("/api/v1/category/") { ctx ->
+            ctx.json(getCategoryList())
+        }
+
+        // category create
+        app.post("/api/v1/category/") { ctx ->
+            val name = ctx.formParam("name")!!
+            createCategory(name)
+            ctx.status(200)
+        }
+
+        // category modification
+        app.patch("/api/v1/category/:categoryId") { ctx ->
+            val categoryId = ctx.pathParam("categoryId").toInt()
+            val name = ctx.formParam("name")
+            val isLanding = if (ctx.formParam("isLanding") != null) ctx.formParam("isLanding")?.toBoolean() else null
+            updateCategory(categoryId, name, isLanding)
+            ctx.status(200)
+        }
+
+        // category re-ordering
+        app.patch("/api/v1/category/:categoryId/reorder") { ctx ->
+            val categoryId = ctx.pathParam("categoryId").toInt()
+            val from = ctx.formParam("from")!!.toInt()
+            val to = ctx.formParam("to")!!.toInt()
+            reorderCategory(categoryId, from, to)
+            ctx.status(200)
+        }
+
+        // category delete
+        app.delete("/api/v1/category/:categoryId") { ctx ->
+            val categoryId = ctx.pathParam("categoryId").toInt()
+            removeCategory(categoryId)
+            ctx.status(200)
+        }
+
+        // returns the manga list associated with a category
+        app.get("/api/v1/category/:categoryId") { ctx ->
+            val categoryId = ctx.pathParam("categoryId").toInt()
+            ctx.json(getCategoryMangaList(categoryId))
+        }
+
+        // expects a Tachiyomi legacy backup json in the body
+        app.post("/api/v1/backup/legacy/import") { ctx ->
+            ctx.result(
+                future {
+                    restoreLegacyBackup(ctx.bodyAsInputStream())
+                }
+            )
+        }
+
+        // expects a Tachiyomi legacy backup json as a file upload, the file must be named "backup.json"
+        app.post("/api/v1/backup/legacy/import/file") { ctx ->
+            ctx.result(
+                future {
+                    restoreLegacyBackup(ctx.uploadedFile("backup.json")!!.content)
+                }
+            )
+        }
+
+        // returns a Tachiyomi legacy backup json created from the current database as a json body
+        app.get("/api/v1/backup/legacy/export") { ctx ->
+            ctx.contentType("application/json")
+            ctx.result(
+                future {
+                    createLegacyBackup(
+                        BackupFlags(
+                            includeManga = true,
+                            includeCategories = true,
+                            includeChapters = true,
+                            includeTracking = true,
+                            includeHistory = true,
+                        )
+                    )
+                }
+            )
+        }
+
+        // returns a Tachiyomi legacy backup json created from the current database as a file
+        app.get("/api/v1/backup/legacy/export/file") { ctx ->
+            ctx.contentType("application/json")
+            val sdf = SimpleDateFormat("yyyy-MM-dd_HH-mm")
+            val currentDate = sdf.format(Date())
+
+            ctx.header("Content-Disposition", "attachment; filename=\"tachidesk_$currentDate.json\"")
+            ctx.result(
+                future {
+                    createLegacyBackup(
+                        BackupFlags(
+                            includeManga = true,
+                            includeCategories = true,
+                            includeChapters = true,
+                            includeTracking = true,
+                            includeHistory = true,
+                        )
+                    )
+                }
+            )
+        }
     }
 }

server/src/main/kotlin/ir/armor/tachidesk/server/ServerConfig.kt

@@ -16,7 +16,7 @@ class ServerConfig(config: Config) : ConfigModule(config) {
     val port: Int by config
 
     // proxy
-    val socksProxy: Boolean by config
+    val socksProxyEnabled: Boolean by config
     val socksProxyHost: String by config
     val socksProxyPort: String by config
 

server/src/main/kotlin/ir/armor/tachidesk/server/ServerSetup.kt

@@ -10,22 +10,26 @@ package ir.armor.tachidesk.server
 import ch.qos.logback.classic.Level
 import eu.kanade.tachiyomi.App
 import ir.armor.tachidesk.Main
-import ir.armor.tachidesk.database.makeDataBaseTables
+import ir.armor.tachidesk.model.dataclass.makeDataBaseTables
 import ir.armor.tachidesk.server.util.systemTray
 import mu.KotlinLogging
-import net.harawata.appdirs.AppDirsFactory
 import org.kodein.di.DI
+import org.kodein.di.bind
 import org.kodein.di.conf.global
+import org.kodein.di.singleton
+import org.slf4j.Logger
 import xyz.nulldev.androidcompat.AndroidCompat
 import xyz.nulldev.androidcompat.AndroidCompatInitializer
+import xyz.nulldev.ts.config.ApplicationRootDir
 import xyz.nulldev.ts.config.ConfigKodeinModule
 import xyz.nulldev.ts.config.GlobalConfigManager
 import java.io.File
 
 private val logger = KotlinLogging.logger {}
 
-object applicationDirs {
-    val dataRoot = AppDirsFactory.getInstance().getUserDataDir("Tachidesk", null, null)!!
+class ApplicationDirs(
+    val dataRoot: String = ApplicationRootDir
+) {
     val extensionsRoot = "$dataRoot/extensions"
     val thumbnailsRoot = "$dataRoot/thumbnails"
     val mangaRoot = "$dataRoot/manga"
@@ -38,26 +42,41 @@ val systemTray by lazy { systemTray() }
 val androidCompat by lazy { AndroidCompat() }
 
 fun applicationSetup() {
-    // register server config
-    GlobalConfigManager.registerModule(
-        ServerConfig.register(GlobalConfigManager.config)
+    // Application dirs
+    val applicationDirs = ApplicationDirs()
+    DI.global.addImport(
+        DI.Module("Server") {
+            bind<ApplicationDirs>() with singleton { applicationDirs }
+        }
     )
 
-    // set application wide logging level
-    if (serverConfig.debugLogsEnabled) {
-        (mu.KotlinLogging.logger(org.slf4j.Logger.ROOT_LOGGER_NAME).underlyingLogger as ch.qos.logback.classic.Logger).level = Level.DEBUG
-    }
-
     // make dirs we need
     listOf(
         applicationDirs.dataRoot,
         applicationDirs.extensionsRoot,
-        "${applicationDirs.extensionsRoot}/icon",
+        applicationDirs.extensionsRoot + "/icon",
         applicationDirs.thumbnailsRoot
     ).forEach {
         File(it).mkdirs()
     }
 
+    // register Tachidesk's config which is dubbed "ServerConfig"
+    GlobalConfigManager.registerModule(
+        ServerConfig.register(GlobalConfigManager.config)
+    )
+
+    // Load config API
+    DI.global.addImport(ConfigKodeinModule().create())
+    // Load Android compatibility dependencies
+    AndroidCompatInitializer().init()
+    // start app
+    androidCompat.startApp(App())
+
+    // set application wide logging level
+    if (serverConfig.debugLogsEnabled) {
+        (KotlinLogging.logger(Logger.ROOT_LOGGER_NAME).underlyingLogger as ch.qos.logback.classic.Logger).level = Level.DEBUG
+    }
+
     // create conf file if doesn't exist
     try {
         val dataConfFile = File("${applicationDirs.dataRoot}/server.conf")
@@ -75,19 +94,13 @@ fun applicationSetup() {
     makeDataBaseTables()
 
     // create system tray
-    if (serverConfig.systemTrayEnabled)
+    if (serverConfig.systemTrayEnabled) {
         try {
             systemTray
         } catch (e: Exception) {
             e.printStackTrace()
         }
-
-    // Load config API
-    DI.global.addImport(ConfigKodeinModule().create())
-    // Load Android compatibility dependencies
-    AndroidCompatInitializer().init()
-    // start app
-    androidCompat.startApp(App())
+    }
 
     // Disable jetty's logging
     System.setProperty("org.eclipse.jetty.util.log.announce", "false")
@@ -95,7 +108,10 @@ fun applicationSetup() {
     System.setProperty("org.eclipse.jetty.LEVEL", "OFF")
 
     // socks proxy settings
-    System.getProperties()["proxySet"] = serverConfig.socksProxy.toString()
-    System.getProperties()["socksProxyHost"] = serverConfig.socksProxyHost
-    System.getProperties()["socksProxyPort"] = serverConfig.socksProxyPort
+    if (serverConfig.socksProxyEnabled) {
+//        System.getProperties()["proxySet"] = "true"
+        System.getProperties()["socksProxyHost"] = serverConfig.socksProxyHost
+        System.getProperties()["socksProxyPort"] = serverConfig.socksProxyPort
+        logger.info("Socks Proxy is enabled to ${serverConfig.socksProxyHost}:${serverConfig.socksProxyPort}")
+    }
 }

server/src/main/kotlin/ir/armor/tachidesk/server/util/SystemTray.kt

@@ -20,8 +20,8 @@ import java.io.IOException
 fun openInBrowser() {
     try {
         Desktop.browseURL("http://127.0.0.1:4567")
-    } catch (e1: IOException) {
-        e1.printStackTrace()
+    } catch (e: Exception) {
+        e.printStackTrace()
     }
 }
 

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

@@ -3,7 +3,7 @@ server.ip = "0.0.0.0"
 server.port = 4567
 
 # Socks5 proxy
-server.socksProxy = false
+server.socksProxyEnabled = false
 server.socksProxyHost = ""
 server.socksProxyPort = ""
 

server/src/test/kotlin/ir/armor/tachidesk/TestExtensions.kt

@@ -0,0 +1,197 @@
+package ir.armor.tachidesk
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 eu.kanade.tachiyomi.source.model.SChapter
+import eu.kanade.tachiyomi.source.model.SManga
+import eu.kanade.tachiyomi.source.online.HttpSource
+import ir.armor.tachidesk.impl.Extension.installExtension
+import ir.armor.tachidesk.impl.Extension.uninstallExtension
+import ir.armor.tachidesk.impl.Extension.updateExtension
+import ir.armor.tachidesk.impl.ExtensionsList.getExtensionList
+import ir.armor.tachidesk.impl.Source.getSourceList
+import ir.armor.tachidesk.impl.util.GetHttpSource.getHttpSource
+import ir.armor.tachidesk.impl.util.awaitSingle
+import ir.armor.tachidesk.model.dataclass.ExtensionDataClass
+import ir.armor.tachidesk.server.applicationSetup
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.sync.Semaphore
+import kotlinx.coroutines.sync.withPermit
+import mu.KotlinLogging
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInstance
+import rx.Observable
+import java.io.File
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class TestExtensions {
+    private val logger = KotlinLogging.logger {}
+    private lateinit var extensions: List<ExtensionDataClass>
+    private lateinit var sources: List<HttpSource>
+
+    private val mangaToFetch = mutableListOf<Pair<HttpSource, SManga>>()
+    private val failedToFetch = mutableListOf<Pair<HttpSource, Exception>>()
+    private val mangaFailedToFetch = mutableListOf<Triple<HttpSource, SManga, Exception>>()
+    private val chaptersToFetch = mutableListOf<Triple<HttpSource, SManga, SChapter>>()
+    private val chaptersFailedToFetch = mutableListOf<Triple<HttpSource, SManga, Throwable>>()
+    private val chaptersPageListFailedToFetch = mutableListOf<Triple<HttpSource, Pair<SManga, SChapter>, Exception>>()
+
+    @BeforeAll
+    fun setup() {
+        val dataRoot = File("tmp/TestDesk").absolutePath
+        System.setProperty("ir.armor.tachidesk.rootDir", dataRoot)
+        applicationSetup()
+        setLoggingEnabled(false)
+
+        runBlocking {
+            extensions = getExtensionList()
+            extensions.forEach {
+                when {
+                    it.obsolete -> {
+                        uninstallExtension(it.pkgName)
+                    }
+                    it.hasUpdate -> {
+                        updateExtension(it.pkgName)
+                    }
+                    else -> {
+                        installExtension(it.pkgName)
+                    }
+                }
+            }
+            sources = getSourceList().map { getHttpSource(it.id.toLong()) }
+        }
+        setLoggingEnabled(true)
+        File("tmp/TestDesk/sources.txt").writeText(sources.joinToString("\n") { "${it.name} - ${it.lang.toUpperCase()} - ${it.id}" })
+    }
+
+    @Test
+    fun runTest() {
+        runBlocking(Dispatchers.Default) {
+            val semaphore = Semaphore(10)
+            sources.mapIndexed { index, source ->
+                async {
+                    semaphore.withPermit {
+                        logger.info { "$index - Now fetching popular manga from $source" }
+                        try {
+                            mangaToFetch += source to (
+                                source.fetchPopularManga(1)
+                                    .awaitSingleRepeat().mangas.firstOrNull()
+                                    ?: throw Exception("Source returned no manga")
+                                )
+                        } catch (e: Exception) {
+                            logger.warn { "Failed to fetch popular manga from $source: ${e.message}" }
+                            failedToFetch += source to e
+                        }
+                    }
+                }
+            }.awaitAll()
+            File("tmp/TestDesk/failedToFetch.txt").writeText(
+                failedToFetch.joinToString("\n") { (source, exception) ->
+                    "${source.name} (${source.lang.toUpperCase()}, ${source.id}):" +
+                        " ${exception.message}"
+                }
+            )
+            logger.info { "Now fetching manga info from ${mangaToFetch.size} sources" }
+
+            mangaToFetch.mapIndexed { index, (source, manga) ->
+                async {
+                    semaphore.withPermit {
+                        logger.info { "$index - Now fetching manga from $source" }
+                        try {
+                            manga.copyFrom(source.fetchMangaDetails(manga).awaitSingleRepeat())
+                            manga.initialized = true
+                        } catch (e: Exception) {
+                            logger.warn {
+                                "Failed to fetch manga info from $source for ${manga.title} (${source.mangaDetailsRequest(manga).url}): ${e.message}"
+                            }
+                            mangaFailedToFetch += Triple(source, manga, e)
+                        }
+                    }
+                }
+            }.awaitAll()
+            File("tmp/TestDesk/MangaFailedToFetch.txt").writeText(
+                mangaFailedToFetch.joinToString("\n") { (source, manga, exception) ->
+                    "${source.name} (${source.lang}, ${source.id}):" +
+                        " ${manga.title} (${source.mangaDetailsRequest(manga).url}):" +
+                        " ${exception.message}"
+                }
+            )
+            logger.info { "Now fetching manga chapters from ${mangaToFetch.size} sources" }
+
+            mangaToFetch.filter { it.second.initialized }.mapIndexed { index, (source, manga) ->
+                async {
+                    semaphore.withPermit {
+                        logger.info { "$index - Now fetching manga chapters from $source" }
+                        try {
+                            chaptersToFetch += Triple(
+                                source,
+                                manga,
+                                source.fetchChapterList(manga).awaitSingleRepeat().firstOrNull() ?: throw Exception("Source returned no chapters")
+                            )
+                        } catch (e: Exception) {
+                            logger.warn {
+                                "Failed to fetch manga chapters from $source for ${manga.title} (${source.mangaDetailsRequest(manga).url}): ${e.message}"
+                            }
+                            chaptersFailedToFetch += Triple(source, manga, e)
+                        } catch (e: NoClassDefFoundError) {
+                            logger.warn {
+                                "Failed to fetch manga chapters from $source for ${manga.title} (${source.mangaDetailsRequest(manga).url}): ${e.message}"
+                            }
+                            chaptersFailedToFetch += Triple(source, manga, e)
+                        }
+                    }
+                }
+            }.awaitAll()
+
+            File("tmp/TestDesk/ChaptersFailedToFetch.txt").writeText(
+                chaptersFailedToFetch.joinToString("\n") { (source, manga, exception) ->
+                    "${source.name} (${source.lang}, ${source.id}):" +
+                        " ${manga.title} (${source.mangaDetailsRequest(manga).url}):" +
+                        " ${exception.message}"
+                }
+            )
+
+            chaptersToFetch.mapIndexed { index, (source, manga, chapter) ->
+                async {
+                    semaphore.withPermit {
+                        logger.info { "$index - Now fetching page list from $source" }
+                        try {
+                            source.fetchPageList(chapter).awaitSingleRepeat()
+                        } catch (e: Exception) {
+                            logger.warn {
+                                "Failed to fetch manga info from $source for ${manga.title} (${source.mangaDetailsRequest(manga).url}): ${e.message}"
+                            }
+                            chaptersPageListFailedToFetch += Triple(source, manga to chapter, e)
+                        }
+                    }
+                }
+            }.awaitAll()
+
+            File("tmp/TestDesk/ChapterPageListFailedToFetch.txt").writeText(
+                chaptersPageListFailedToFetch.joinToString("\n") { (source, manga, exception) ->
+                    "${source.name} (${source.lang}, ${source.id}):" +
+                        " ${manga.first.title} (${source.mangaDetailsRequest(manga.first).url}):" +
+                        " ${manga.second.name} (${manga.second.url}): ${exception.message}"
+                }
+            )
+        }
+    }
+
+    private suspend fun <T> Observable<T>.awaitSingleRepeat(): T {
+        for (i in 1..2) {
+            try {
+                return awaitSingle()
+            } catch (e: Exception) {}
+        }
+        return awaitSingle()
+    }
+}

server/src/test/kotlin/ir/armor/tachidesk/TestUtils.kt

@@ -0,0 +1,19 @@
+package ir.armor.tachidesk
+
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 ch.qos.logback.classic.Level
+import mu.KotlinLogging
+import org.slf4j.Logger
+
+fun setLoggingEnabled(enabled: Boolean = true) {
+    val logger = (KotlinLogging.logger(Logger.ROOT_LOGGER_NAME).underlyingLogger as ch.qos.logback.classic.Logger)
+    logger.level = if (enabled) {
+        Level.DEBUG
+    } else Level.ERROR
+}

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

@@ -0,0 +1,13 @@
+# Server ip and port bindings
+server.ip = "0.0.0.0"
+server.port = 4567
+
+# Socks5 proxy
+server.socksProxy = false
+server.socksProxyHost = ""
+server.socksProxyPort = ""
+
+# misc
+server.debugLogsEnabled = true
+server.systemTrayEnabled = false
+server.initialOpenInBrowserEnabled = true

webUI/react/package.json

@@ -10,6 +10,7 @@
     "@testing-library/user-event": "^12.1.10",
     "@types/react-lazyload": "^3.1.0",
     "axios": "^0.21.1",
+    "file-selector": "^0.2.4",
     "fontsource-roboto": "^4.0.0",
     "react": "^17.0.1",
     "react-beautiful-dnd": "^13.0.0",

webUI/react/src/App.tsx

@@ -25,6 +25,7 @@ import DarkTheme from './context/DarkTheme';
 import Library from './screens/Library';
 import Settings from './screens/Settings';
 import Categories from './screens/settings/Categories';
+import Backup from './screens/settings/Backup';
 import useLocalStorage from './util/useLocalStorage';
 
 export default function App() {
@@ -103,6 +104,9 @@ export default function App() {
                             <Route path="/settings/categories">
                                 <Categories />
                             </Route>
+                            <Route path="/settings/backup">
+                                <Backup />
+                            </Route>
                             <Route path="/settings">
                                 <DarkTheme.Provider value={darkThemeContext}>
                                     <Settings />

webUI/react/src/components/ExtensionCard.tsx

@@ -49,11 +49,17 @@ interface IProps {
 export default function ExtensionCard(props: IProps) {
     const {
         extension: {
-            name, lang, versionName, installed, apkName, iconUrl,
+            name, lang, versionName, installed, hasUpdate, obsolete, pkgName, iconUrl,
         },
         notifyInstall,
     } = props;
-    const [installedState, setInstalledState] = useState<string>((installed ? 'uninstall' : 'install'));
+    const [installedState, setInstalledState] = useState<string>(
+        () => {
+            if (obsolete) { return 'obsolete'; }
+            if (hasUpdate) { return 'update'; }
+            return (installed ? 'uninstall' : 'install');
+        },
+    );
 
     const [serverAddress] = useLocalStorage<String>('serverBaseURL', '');
 
@@ -62,7 +68,16 @@ export default function ExtensionCard(props: IProps) {
 
     function install() {
         setInstalledState('installing');
-        client.get(`/api/v1/extension/install/${apkName}`)
+        client.get(`/api/v1/extension/install/${pkgName}`)
+            .then(() => {
+                setInstalledState('uninstall');
+                notifyInstall();
+            });
+    }
+
+    function update() {
+        setInstalledState('updating');
+        client.get(`/api/v1/extension/update/${pkgName}`)
             .then(() => {
                 setInstalledState('uninstall');
                 notifyInstall();
@@ -71,7 +86,7 @@ export default function ExtensionCard(props: IProps) {
 
     function uninstall() {
         setInstalledState('uninstalling');
-        client.get(`/api/v1/extension/uninstall/${apkName}`)
+        client.get(`/api/v1/extension/uninstall/${pkgName}`)
             .then(() => {
                 // setInstalledState('install');
                 notifyInstall();
@@ -79,10 +94,22 @@ export default function ExtensionCard(props: IProps) {
     }
 
     function handleButtonClick() {
-        if (installedState === 'install') {
-            install();
-        } else {
-            uninstall();
+        switch (installedState) {
+            case 'install':
+                install();
+                break;
+            case 'update':
+                update();
+                break;
+            case 'obsolete':
+                uninstall();
+                setTimeout(() => window.location.reload(), 3000);
+                break;
+            case 'uninstall':
+                uninstall();
+                break;
+            default:
+                break;
         }
     }
 
@@ -108,7 +135,14 @@ export default function ExtensionCard(props: IProps) {
                     </div>
                 </div>
 
-                <Button variant="outlined" onClick={() => handleButtonClick()}>{installedState}</Button>
+                <Button
+                    variant="outlined"
+                    style={{ color: installedState === 'obsolete' ? 'red' : 'inherit' }}
+                    onClick={() => handleButtonClick()}
+                >
+                    {installedState}
+
+                </Button>
             </CardContent>
         </Card>
     );

webUI/react/src/components/MangaDetails.tsx

@@ -135,6 +135,9 @@ export default function MangaDetails(props: IProps) {
     const { setAction } = useContext(NavbarContext);
 
     const { manga } = props;
+    if (manga.genre == null) {
+        manga.genre = '';
+    }
     const [inLibrary, setInLibrary] = useState<string>(
         manga.inLibrary ? 'In Library' : 'Add To Library',
     );

webUI/react/src/screens/Extensions.tsx

@@ -17,7 +17,7 @@ const allLangs: string[] = [];
 
 function groupExtensions(extensions: IExtension[]) {
     allLangs.length = 0; // empty the array
-    const result = { installed: [] } as any;
+    const result = { installed: [], 'updates pending': [] } as any;
     extensions.sort((a, b) => ((a.apkName > b.apkName) ? 1 : -1));
 
     extensions.forEach((extension) => {
@@ -26,7 +26,11 @@ function groupExtensions(extensions: IExtension[]) {
             if (extension.lang !== 'all') { allLangs.push(extension.lang); }
         }
         if (extension.installed) {
-            result.installed.push(extension);
+            if (extension.hasUpdate) {
+                result['updates pending'].push(extension);
+            } else {
+                result.installed.push(extension);
+            }
         } else {
             result[extension.lang].push(extension);
         }
@@ -79,11 +83,12 @@ export default function Extensions() {
     if (Object.entries(extensions).length === 0) {
         return <h3>loading...</h3>;
     }
+    const groupsToShow = ['updates pending', 'installed', ...shownLangs];
     return (
         <>
             {
                 Object.entries(extensions).map(([lang, list]) => (
-                    ((['installed', ...shownLangs].indexOf(lang) !== -1 && (list as []).length > 0)
+                    ((groupsToShow.indexOf(lang) !== -1 && (list as []).length > 0)
                         && (
                             <React.Fragment key={lang}>
                                 <h1 key={lang} style={{ marginLeft: 25 }}>

webUI/react/src/screens/SearchSingle.tsx

@@ -73,7 +73,7 @@ export default function SearchSingle() {
                             }))]);
                         setHasNextPage(data.hasNextPage);
                     } else {
-                        setMessage('search qeury returned nothing.');
+                        setMessage('search query returned nothing.');
                     }
                 });
         }

webUI/react/src/screens/Settings.tsx

@@ -16,15 +16,11 @@ import {
     DialogContentText, IconButton, ListItemSecondaryAction, Switch, TextField,
     ListItemIcon, ListItemText,
 } from '@material-ui/core';
-import ListItem, { ListItemProps } from '@material-ui/core/ListItem';
+import ListItem from '@material-ui/core/ListItem';
 import NavbarContext from '../context/NavbarContext';
 import DarkTheme from '../context/DarkTheme';
 import useLocalStorage from '../util/useLocalStorage';
-
-function ListItemLink(props: ListItemProps<'a', { button?: true }>) {
-    // eslint-disable-next-line react/jsx-props-no-spreading
-    return <ListItem button component="a" {...props} />;
-}
+import ListItemLink from '../util/ListItemLink';
 
 export default function Settings() {
     const { setTitle, setAction } = useContext(NavbarContext);
@@ -58,6 +54,12 @@ export default function Settings() {
                     </ListItemIcon>
                     <ListItemText primary="Categories" />
                 </ListItemLink>
+                <ListItemLink href="/settings/backup">
+                    <ListItemIcon>
+                        <InboxIcon />
+                    </ListItemIcon>
+                    <ListItemText primary="Backup" />
+                </ListItemLink>
                 <ListItem>
                     <ListItemIcon>
                         <Brightness6Icon />

webUI/react/src/screens/settings/Backup.tsx

@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 React, { useContext, useEffect } from 'react';
+import { ListItemIcon } from '@material-ui/core';
+import List from '@material-ui/core/List';
+import InboxIcon from '@material-ui/icons/Inbox';
+import ListItem from '@material-ui/core/ListItem';
+import ListItemText from '@material-ui/core/ListItemText';
+import { fromEvent } from 'file-selector';
+import ListItemLink from '../../util/ListItemLink';
+import NavbarContext from '../../context/NavbarContext';
+import client from '../../util/client';
+
+export default function Backup() {
+    const { setTitle, setAction } = useContext(NavbarContext);
+    useEffect(() => { setTitle('Backup'); setAction(<></>); }, []);
+
+    const { baseURL } = client.defaults;
+
+    const submitBackup = (file: File) => {
+        file.text()
+            .then(
+                (fileContent: string) => {
+                    client.post('/api/v1/backup/legacy/import',
+                        fileContent, { headers: { 'Content-Type': 'application/json' } });
+                },
+            );
+    };
+
+    const dropHandler = async (e: Event) => {
+        e.preventDefault();
+        const files = await fromEvent(e);
+
+        submitBackup(files[0] as File);
+    };
+
+    const dragOverHandler = (e: Event) => {
+        e.preventDefault();
+    };
+
+    useEffect(() => {
+        document.addEventListener('drop', dropHandler);
+        document.addEventListener('dragover', dragOverHandler);
+
+        const input = document.getElementById('backup-file');
+        input?.addEventListener('change', async (evt) => {
+            const files = await fromEvent(evt);
+            submitBackup(files[0] as File);
+        });
+
+        return () => {
+            document.removeEventListener('drop', dropHandler);
+            document.removeEventListener('dragover', dragOverHandler);
+        };
+    }, []);
+
+    return (
+        <List style={{ padding: 0 }}>
+            <ListItemLink href={`${baseURL}/api/v1/backup/legacy/export/file`}>
+                <ListItemIcon>
+                    <InboxIcon />
+                </ListItemIcon>
+                <ListItemText
+                    primary="Create Legacy Backup"
+                    secondary="Backup library as a Tachiyomi legacy backup"
+                />
+            </ListItemLink>
+            <ListItem button onClick={() => document.getElementById('backup-file')?.click()}>
+                <ListItemIcon>
+                    <InboxIcon />
+                </ListItemIcon>
+                <ListItemText
+                    primary="Restore Legacy Backup"
+                    secondary="You can also drop the backup file anywhere to restore"
+                />
+                <input
+                    type="file"
+                    name="backup.json"
+                    id="backup-file"
+                    style={{ display: 'none' }}
+                />
+            </ListItem>
+        </List>
+
+    );
+}

webUI/react/src/typings.d.ts

@@ -7,12 +7,16 @@
 
 interface IExtension {
     name: string
-    lang: string
+    pkgName: string
     versionName: string
+    versionCode: number
+    lang: string
+    isNsfw: boolean
+    apkName: string
     iconUrl: string
     installed: boolean
-    apkName: string
-    pkgName: string
+    hasUpdate: boolean
+    obsolete: boolean
 }
 
 interface ISource {
@@ -77,4 +81,4 @@ interface ICategory {
 interface INavbarOverride {
     status: boolean
     value: any
-}
+}