Manga page Finished

2026-07-02 10:24:35 -05:00 · 2021-05-27 17:13:22 +04:30
parent c17e3bd04f
commit 5c7123a997
29 changed files with 1857 additions and 103 deletions
--- a/server/src/main/kotlin/eu/kanade/tachiyomi/source/AnimeSource.kt
+++ b/server/src/main/kotlin/eu/kanade/tachiyomi/source/AnimeSource.kt
@@ -24,7 +24,7 @@ interface AnimeSource {
     *
     * @param anime the anime to update.
     */
-    @Deprecated("Use getAnimeDetails instead")
+//    @Deprecated("Use getAnimeDetails instead")
    fun fetchAnimeDetails(anime: SAnime): Observable<SAnime>

    /**
@@ -32,7 +32,7 @@ interface AnimeSource {
     *
     * @param anime the anime to update.
     */
-    @Deprecated("Use getEpisodeList instead")
+//    @Deprecated("Use getEpisodeList instead")
    fun fetchEpisodeList(anime: SAnime): Observable<List<SEpisode>>

    /**
@@ -40,7 +40,7 @@ interface AnimeSource {
     *
     * @param episode the episode to get the link for.
     */
-    @Deprecated("Use getEpisodeList instead")
+//    @Deprecated("Use getEpisodeList instead")
    fun fetchEpisodeLink(episode: SEpisode): Observable<String>

 //    /**
--- a/server/src/main/kotlin/suwayomi/anime/AnimeAPI.kt
+++ b/server/src/main/kotlin/suwayomi/anime/AnimeAPI.kt
@@ -8,6 +8,14 @@ package suwayomi.anime
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

 import io.javalin.Javalin
+import suwayomi.anime.impl.Anime.getAnime
+import suwayomi.anime.impl.Anime.getAnimeThumbnail
+import suwayomi.anime.impl.AnimeList.getAnimeList
+import suwayomi.anime.impl.Episode.getEpisode
+import suwayomi.anime.impl.Episode.getEpisodeList
+import suwayomi.anime.impl.Episode.modifyEpisode
+import suwayomi.anime.impl.Source.getAnimeSource
+import suwayomi.anime.impl.Source.getSourceList
 import suwayomi.anime.impl.extension.Extension.getExtensionIcon
 import suwayomi.anime.impl.extension.Extension.installExtension
 import suwayomi.anime.impl.extension.Extension.uninstallExtension
@@ -70,63 +78,63 @@ object AnimeAPI {
            )
        }

-//        // list of sources
-//        app.get("/api/v1/source/list") { ctx ->
-//            ctx.json(getSourceList())
-//        }
-//
-//        // fetch source with id `sourceId`
-//        app.get("/api/v1/source/:sourceId") { ctx ->
-//            val sourceId = ctx.pathParam("sourceId").toLong()
-//            ctx.json(getSource(sourceId))
-//        }
-//
-//        // 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(
-//                JavalinSetup.future {
-//                    getMangaList(sourceId, pageNum, popular = true)
-//                }
-//            )
-//        }
-//
-//        // 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(
-//                JavalinSetup.future {
-//                    getMangaList(sourceId, pageNum, popular = false)
-//                }
-//            )
-//        }
-//
-//        // get manga info
-//        app.get("/api/v1/manga/:mangaId/") { ctx ->
-//            val mangaId = ctx.pathParam("mangaId").toInt()
-//            val onlineFetch = ctx.queryParam("onlineFetch", "false").toBoolean()
-//
-//            ctx.json(
-//                JavalinSetup.future {
-//                    getManga(mangaId, onlineFetch)
-//                }
-//            )
-//        }
-//
-//        // manga thumbnail
-//        app.get("api/v1/manga/:mangaId/thumbnail") { ctx ->
-//            val mangaId = ctx.pathParam("mangaId").toInt()
-//
-//            ctx.result(
-//                JavalinSetup.future { getMangaThumbnail(mangaId) }
-//                    .thenApply {
-//                        ctx.header("content-type", it.second)
-//                        it.first
-//                    }
-//            )
-//        }
+        // list of sources
+        app.get("/api/v1/anime/source/list") { ctx ->
+            ctx.json(getSourceList())
+        }
+
+        // fetch source with id `sourceId`
+        app.get("/api/v1/anime/source/:sourceId") { ctx ->
+            val sourceId = ctx.pathParam("sourceId").toLong()
+            ctx.json(getAnimeSource(sourceId))
+        }
+
+        // popular animes from source with id `sourceId`
+        app.get("/api/v1/anime/source/:sourceId/popular/:pageNum") { ctx ->
+            val sourceId = ctx.pathParam("sourceId").toLong()
+            val pageNum = ctx.pathParam("pageNum").toInt()
+            ctx.json(
+                JavalinSetup.future {
+                    getAnimeList(sourceId, pageNum, popular = true)
+                }
+            )
+        }
+
+        // latest animes from source with id `sourceId`
+        app.get("/api/v1/anime/source/:sourceId/latest/:pageNum") { ctx ->
+            val sourceId = ctx.pathParam("sourceId").toLong()
+            val pageNum = ctx.pathParam("pageNum").toInt()
+            ctx.json(
+                JavalinSetup.future {
+                    getAnimeList(sourceId, pageNum, popular = false)
+                }
+            )
+        }
+
+        // get anime info
+        app.get("/api/v1/anime/anime/:animeId/") { ctx ->
+            val animeId = ctx.pathParam("animeId").toInt()
+            val onlineFetch = ctx.queryParam("onlineFetch", "false").toBoolean()
+
+            ctx.json(
+                JavalinSetup.future {
+                    getAnime(animeId, onlineFetch)
+                }
+            )
+        }
+
+        // anime thumbnail
+        app.get("api/v1/anime/anime/:animeId/thumbnail") { ctx ->
+            val animeId = ctx.pathParam("animeId").toInt()
+
+            ctx.result(
+                JavalinSetup.future { getAnimeThumbnail(animeId) }
+                    .thenApply {
+                        ctx.header("content-type", it.second)
+                        it.first
+                    }
+            )
+        }
 //
 //        // list manga's categories
 //        app.get("api/v1/manga/:mangaId/category/") { ctx ->
@@ -150,36 +158,36 @@ object AnimeAPI {
 //            ctx.status(200)
 //        }
 //
-//        // get chapter list when showing a manga
-//        app.get("/api/v1/manga/:mangaId/chapters") { ctx ->
-//            val mangaId = ctx.pathParam("mangaId").toInt()
-//
-//            val onlineFetch = ctx.queryParam("onlineFetch")?.toBoolean()
-//
-//            ctx.json(JavalinSetup.future { getChapterList(mangaId, onlineFetch) })
-//        }
-//
-//        // 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(JavalinSetup.future { getChapter(chapterIndex, mangaId) })
-//        }
-//
-//        // used to modify a chapter's parameters
-//        app.patch("/api/v1/manga/:mangaId/chapter/:chapterIndex") { ctx ->
-//            val chapterIndex = ctx.pathParam("chapterIndex").toInt()
-//            val mangaId = ctx.pathParam("mangaId").toInt()
-//
-//            val read = ctx.formParam("read")?.toBoolean()
-//            val bookmarked = ctx.formParam("bookmarked")?.toBoolean()
-//            val markPrevRead = ctx.formParam("markPrevRead")?.toBoolean()
-//            val lastPageRead = ctx.formParam("lastPageRead")?.toInt()
-//
-//            modifyChapter(mangaId, chapterIndex, read, bookmarked, markPrevRead, lastPageRead)
-//
-//            ctx.status(200)
-//        }
+        // get episode list when showing a anime
+        app.get("/api/v1/anime/anime/:animeId/episodes") { ctx ->
+            val animeId = ctx.pathParam("animeId").toInt()
+
+            val onlineFetch = ctx.queryParam("onlineFetch")?.toBoolean()
+
+            ctx.json(JavalinSetup.future { getEpisodeList(animeId, onlineFetch) })
+        }
+
+        // used to display a episode, get a episode in order to show it's <Quality pending>
+        app.get("/api/v1/anime/anime/:animeId/episode/:episodeIndex") { ctx ->
+            val episodeIndex = ctx.pathParam("episodeIndex").toInt()
+            val animeId = ctx.pathParam("animeId").toInt()
+            ctx.json(JavalinSetup.future { getEpisode(episodeIndex, animeId) })
+        }
+
+        // used to modify a episode's parameters
+        app.patch("/api/v1/anime/anime/:animeId/episode/:episodeIndex") { ctx ->
+            val episodeIndex = ctx.pathParam("episodeIndex").toInt()
+            val animeId = ctx.pathParam("animeId").toInt()
+
+            val read = ctx.formParam("read")?.toBoolean()
+            val bookmarked = ctx.formParam("bookmarked")?.toBoolean()
+            val markPrevRead = ctx.formParam("markPrevRead")?.toBoolean()
+            val lastPageRead = ctx.formParam("lastPageRead")?.toInt()
+
+            modifyEpisode(animeId, episodeIndex, read, bookmarked, markPrevRead, lastPageRead)
+
+            ctx.status(200)
+        }
 //
 //        // get page at index "index"
 //        app.get("/api/v1/manga/:mangaId/chapter/:chapterIndex/page/:index") { ctx ->
--- a/server/src/main/kotlin/suwayomi/anime/impl/Anime.kt
+++ b/server/src/main/kotlin/suwayomi/anime/impl/Anime.kt
@@ -0,0 +1,139 @@
+package suwayomi.anime.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.network.GET
+import eu.kanade.tachiyomi.source.model.SAnime
+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 suwayomi.anime.impl.AnimeList.proxyThumbnailUrl
+import suwayomi.anime.impl.Source.getAnimeSource
+import suwayomi.anime.impl.util.GetAnimeHttpSource.getAnimeHttpSource
+import suwayomi.anime.model.dataclass.AnimeDataClass
+import suwayomi.anime.model.table.AnimeStatus
+import suwayomi.anime.model.table.AnimeTable
+import suwayomi.server.ApplicationDirs
+import suwayomi.tachidesk.impl.util.lang.awaitSingle
+import suwayomi.tachidesk.impl.util.network.await
+import suwayomi.tachidesk.impl.util.storage.CachedImageResponse.clearCachedImage
+import suwayomi.tachidesk.impl.util.storage.CachedImageResponse.getCachedImageResponse
+import java.io.InputStream
+
+object Anime {
+    private fun truncate(text: String?, maxLength: Int): String? {
+        return if (text?.length ?: 0 > maxLength)
+            text?.take(maxLength - 3) + "..."
+        else
+            text
+    }
+
+    suspend fun getAnime(animeId: Int, onlineFetch: Boolean = false): AnimeDataClass {
+        var animeEntry = transaction { AnimeTable.select { AnimeTable.id eq animeId }.first() }
+
+        return if (animeEntry[AnimeTable.initialized] && !onlineFetch) {
+            AnimeDataClass(
+                animeId,
+                animeEntry[AnimeTable.sourceReference].toString(),
+
+                animeEntry[AnimeTable.url],
+                animeEntry[AnimeTable.title],
+                proxyThumbnailUrl(animeId),
+
+                true,
+
+                animeEntry[AnimeTable.artist],
+                animeEntry[AnimeTable.author],
+                animeEntry[AnimeTable.description],
+                animeEntry[AnimeTable.genre],
+                AnimeStatus.valueOf(animeEntry[AnimeTable.status]).name,
+                animeEntry[AnimeTable.inLibrary],
+                getAnimeSource(animeEntry[AnimeTable.sourceReference]),
+                false
+            )
+        } else { // initialize anime
+            val source = getAnimeHttpSource(animeEntry[AnimeTable.sourceReference])
+            val fetchedAnime = source.fetchAnimeDetails(
+                SAnime.create().apply {
+                    url = animeEntry[AnimeTable.url]
+                    title = animeEntry[AnimeTable.title]
+                }
+            ).awaitSingle()
+
+            transaction {
+                AnimeTable.update({ AnimeTable.id eq animeId }) {
+
+                    it[AnimeTable.initialized] = true
+
+                    it[AnimeTable.artist] = fetchedAnime.artist
+                    it[AnimeTable.author] = fetchedAnime.author
+                    it[AnimeTable.description] = truncate(fetchedAnime.description, 4096)
+                    it[AnimeTable.genre] = fetchedAnime.genre
+                    it[AnimeTable.status] = fetchedAnime.status
+                    if (fetchedAnime.thumbnail_url != null && fetchedAnime.thumbnail_url.orEmpty().isNotEmpty())
+                        it[AnimeTable.thumbnail_url] = fetchedAnime.thumbnail_url
+                }
+            }
+
+            clearAnimeThumbnail(animeId)
+
+            animeEntry = transaction { AnimeTable.select { AnimeTable.id eq animeId }.first() }
+
+            AnimeDataClass(
+                animeId,
+                animeEntry[AnimeTable.sourceReference].toString(),
+
+                animeEntry[AnimeTable.url],
+                animeEntry[AnimeTable.title],
+                proxyThumbnailUrl(animeId),
+
+                true,
+
+                fetchedAnime.artist,
+                fetchedAnime.author,
+                fetchedAnime.description,
+                fetchedAnime.genre,
+                AnimeStatus.valueOf(fetchedAnime.status).name,
+                false,
+                getAnimeSource(animeEntry[AnimeTable.sourceReference]),
+                true
+            )
+        }
+    }
+
+    private val applicationDirs by DI.global.instance<ApplicationDirs>()
+    suspend fun getAnimeThumbnail(animeId: Int): Pair<InputStream, String> {
+        val saveDir = applicationDirs.animeThumbnailsRoot
+        val fileName = animeId.toString()
+
+        return getCachedImageResponse(saveDir, fileName) {
+            getAnime(animeId) // make sure is initialized
+
+            val animeEntry = transaction { AnimeTable.select { AnimeTable.id eq animeId }.first() }
+
+            val sourceId = animeEntry[AnimeTable.sourceReference]
+            val source = getAnimeHttpSource(sourceId)
+
+            val thumbnailUrl = animeEntry[AnimeTable.thumbnail_url]!!
+
+            source.client.newCall(
+                GET(thumbnailUrl, source.headers)
+            ).await()
+        }
+    }
+
+    private fun clearAnimeThumbnail(animeId: Int) {
+        val saveDir = applicationDirs.animeThumbnailsRoot
+        val fileName = animeId.toString()
+
+        clearCachedImage(saveDir, fileName)
+    }
+}
--- a/server/src/main/kotlin/suwayomi/anime/impl/AnimeList.kt
+++ b/server/src/main/kotlin/suwayomi/anime/impl/AnimeList.kt
@@ -0,0 +1,102 @@
+package suwayomi.anime.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.model.AnimesPage
+import org.jetbrains.exposed.sql.insertAndGetId
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.transactions.transaction
+import suwayomi.anime.impl.util.GetAnimeHttpSource.getAnimeHttpSource
+import suwayomi.anime.model.dataclass.AnimeDataClass
+import suwayomi.anime.model.dataclass.PagedAnimeListDataClass
+import suwayomi.anime.model.table.AnimeStatus
+import suwayomi.anime.model.table.AnimeTable
+import suwayomi.tachidesk.impl.util.lang.awaitSingle
+
+object AnimeList {
+    fun proxyThumbnailUrl(animeId: Int): String {
+        return "/api/v1/anime/anime/$animeId/thumbnail"
+    }
+
+    suspend fun getAnimeList(sourceId: Long, pageNum: Int = 1, popular: Boolean): PagedAnimeListDataClass {
+        val source = getAnimeHttpSource(sourceId)
+        val animesPage = if (popular) {
+            source.fetchPopularAnime(pageNum).awaitSingle()
+        } else {
+            if (source.supportsLatest)
+                source.fetchLatestUpdates(pageNum).awaitSingle()
+            else
+                throw Exception("Source $source doesn't support latest")
+        }
+        return animesPage.processEntries(sourceId)
+    }
+
+    fun AnimesPage.processEntries(sourceId: Long): PagedAnimeListDataClass {
+        val animesPage = this
+        val animeList = transaction {
+            return@transaction animesPage.animes.map { anime ->
+                val animeEntry = AnimeTable.select { AnimeTable.url eq anime.url }.firstOrNull()
+                if (animeEntry == null) { // create anime entry
+                    val animeId = AnimeTable.insertAndGetId {
+                        it[url] = anime.url
+                        it[title] = anime.title
+
+                        it[artist] = anime.artist
+                        it[author] = anime.author
+                        it[description] = anime.description
+                        it[genre] = anime.genre
+                        it[status] = anime.status
+                        it[thumbnail_url] = anime.thumbnail_url
+
+                        it[sourceReference] = sourceId
+                    }.value
+
+                    AnimeDataClass(
+                        animeId,
+                        sourceId.toString(),
+
+                        anime.url,
+                        anime.title,
+                        proxyThumbnailUrl(animeId),
+
+                        anime.initialized,
+
+                        anime.artist,
+                        anime.author,
+                        anime.description,
+                        anime.genre,
+                        AnimeStatus.valueOf(anime.status).name
+                    )
+                } else {
+                    val animeId = animeEntry[AnimeTable.id].value
+                    AnimeDataClass(
+                        animeId,
+                        sourceId.toString(),
+
+                        anime.url,
+                        anime.title,
+                        proxyThumbnailUrl(animeId),
+
+                        true,
+
+                        animeEntry[AnimeTable.artist],
+                        animeEntry[AnimeTable.author],
+                        animeEntry[AnimeTable.description],
+                        animeEntry[AnimeTable.genre],
+                        AnimeStatus.valueOf(animeEntry[AnimeTable.status]).name,
+                        animeEntry[AnimeTable.inLibrary]
+                    )
+                }
+            }
+        }
+        return PagedAnimeListDataClass(
+            animeList,
+            animesPage.hasNextPage
+        )
+    }
+}
--- a/server/src/main/kotlin/suwayomi/anime/impl/Episode.kt
+++ b/server/src/main/kotlin/suwayomi/anime/impl/Episode.kt
@@ -0,0 +1,214 @@
+package suwayomi.anime.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.model.SAnime
+import org.jetbrains.exposed.sql.SortOrder.DESC
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.deleteWhere
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.jetbrains.exposed.sql.update
+import suwayomi.anime.impl.Anime.getAnime
+import suwayomi.anime.impl.util.GetAnimeHttpSource.getAnimeHttpSource
+import suwayomi.anime.model.dataclass.EpisodeDataClass
+import suwayomi.anime.model.table.EpisodeTable
+import suwayomi.anime.model.table.toDataClass
+import suwayomi.tachidesk.impl.util.lang.awaitSingle
+
+object Episode {
+    /** get episode list when showing an anime */
+    suspend fun getEpisodeList(animeId: Int, onlineFetch: Boolean?): List<EpisodeDataClass> {
+        return if (onlineFetch == true) {
+            getSourceEpisodes(animeId)
+        } else {
+            transaction {
+                EpisodeTable.select { EpisodeTable.anime eq animeId }.orderBy(EpisodeTable.episodeIndex to DESC)
+                    .map {
+                        EpisodeTable.toDataClass(it)
+                    }
+            }.ifEmpty {
+                // If it was explicitly set to offline dont grab episodes
+                if (onlineFetch == null) {
+                    getSourceEpisodes(animeId)
+                } else emptyList()
+            }
+        }
+    }
+
+    private suspend fun getSourceEpisodes(animeId: Int): List<EpisodeDataClass> {
+        val animeDetails = getAnime(animeId)
+        val source = getAnimeHttpSource(animeDetails.sourceId.toLong())
+        val episodeList = source.fetchEpisodeList(
+            SAnime.create().apply {
+                title = animeDetails.title
+                url = animeDetails.url
+            }
+        ).awaitSingle()
+
+        val episodeCount = episodeList.count()
+
+        transaction {
+            episodeList.reversed().forEachIndexed { index, fetchedEpisode ->
+                val episodeEntry = EpisodeTable.select { EpisodeTable.url eq fetchedEpisode.url }.firstOrNull()
+                if (episodeEntry == null) {
+                    EpisodeTable.insert {
+                        it[url] = source.
+                        it[name] = fetchedEpisode.name
+                        it[date_upload] = fetchedEpisode.date_upload
+                        it[episode_number] = fetchedEpisode.episode_number
+                        it[scanlator] = fetchedEpisode.scanlator
+
+                        it[episodeIndex] = index + 1
+                        it[anime] = animeId
+                    }
+                } else {
+                    EpisodeTable.update({ EpisodeTable.url eq fetchedEpisode.url }) {
+                        it[name] = fetchedEpisode.name
+                        it[date_upload] = fetchedEpisode.date_upload
+                        it[episode_number] = fetchedEpisode.episode_number
+                        it[scanlator] = fetchedEpisode.scanlator
+
+                        it[episodeIndex] = index + 1
+                        it[anime] = animeId
+                    }
+                }
+            }
+        }
+
+        // clear any orphaned episodes that are in the db but not in `episodeList`
+        val dbEpisodeCount = transaction { EpisodeTable.select { EpisodeTable.anime eq animeId }.count() }
+        if (dbEpisodeCount > episodeCount) { // we got some clean up due
+            val dbEpisodeList = transaction { EpisodeTable.select { EpisodeTable.anime eq animeId } }
+
+            dbEpisodeList.forEach {
+                if (it[EpisodeTable.episodeIndex] >= episodeList.size ||
+                    episodeList[it[EpisodeTable.episodeIndex] - 1].url != it[EpisodeTable.url]
+                ) {
+                    transaction {
+//                        PageTable.deleteWhere { PageTable.episode eq it[EpisodeTable.id] }
+                        EpisodeTable.deleteWhere { EpisodeTable.id eq it[EpisodeTable.id] }
+                    }
+                }
+            }
+        }
+
+        val dbEpisodeMap = transaction {
+            EpisodeTable.select { EpisodeTable.anime eq animeId }
+                .associateBy({ it[EpisodeTable.url] }, { it })
+        }
+
+        return episodeList.mapIndexed { index, it ->
+
+            val dbEpisode = dbEpisodeMap.getValue(it.url)
+
+            EpisodeDataClass(
+                it.url,
+                it.name,
+                it.date_upload,
+                it.episode_number,
+                it.scanlator,
+                animeId,
+
+                dbEpisode[EpisodeTable.isRead],
+                dbEpisode[EpisodeTable.isBookmarked],
+                dbEpisode[EpisodeTable.lastPageRead],
+
+                episodeCount - index,
+                episodeList.size
+            )
+        }
+    }
+
+    /** used to display a episode, get a episode in order to show it's video */
+    suspend fun getEpisode(episodeIndex: Int, animeId: Int): EpisodeDataClass {
+        return getEpisodeList(animeId, true).first { it.index == episodeIndex }
+    }
+
+//    /** used to display a episode, get a episode in order to show it's pages */
+//    suspend fun getEpisode(episodeIndex: Int, animeId: Int): EpisodeDataClass {
+//        val episodeEntry = transaction {
+//            EpisodeTable.select {
+//                (EpisodeTable.episodeIndex eq episodeIndex) and (EpisodeTable.anime eq animeId)
+//            }.first()
+//        }
+//        val animeEntry = transaction { MangaTable.select { MangaTable.id eq animeId }.first() }
+//        val source = getAnimeHttpSource(animeEntry[MangaTable.sourceReference])
+//
+//        val pageList = source.fetchPageList(
+//            SEpisode.create().apply {
+//                url = episodeEntry[EpisodeTable.url]
+//                name = episodeEntry[EpisodeTable.name]
+//            }
+//        ).awaitSingle()
+//
+//        val episodeId = episodeEntry[EpisodeTable.id].value
+//        val episodeCount = transaction { EpisodeTable.select { EpisodeTable.anime eq animeId }.count() }
+//
+//        // update page list for this episode
+//        transaction {
+//            pageList.forEach { page ->
+//                val pageEntry = transaction { PageTable.select { (PageTable.episode eq episodeId) 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[episode] = episodeId
+//                    }
+//                } else {
+//                    PageTable.update({ (PageTable.episode eq episodeId) and (PageTable.index eq page.index) }) {
+//                        it[url] = page.url
+//                        it[imageUrl] = page.imageUrl
+//                    }
+//                }
+//            }
+//        }
+//
+//        return EpisodeDataClass(
+//            episodeEntry[EpisodeTable.url],
+//            episodeEntry[EpisodeTable.name],
+//            episodeEntry[EpisodeTable.date_upload],
+//            episodeEntry[EpisodeTable.episode_number],
+//            episodeEntry[EpisodeTable.scanlator],
+//            animeId,
+//            episodeEntry[EpisodeTable.isRead],
+//            episodeEntry[EpisodeTable.isBookmarked],
+//            episodeEntry[EpisodeTable.lastPageRead],
+//
+//            episodeEntry[EpisodeTable.episodeIndex],
+//            episodeCount.toInt(),
+//            pageList.count()
+//        )
+//    }
+
+    fun modifyEpisode(animeId: Int, episodeIndex: Int, isRead: Boolean?, isBookmarked: Boolean?, markPrevRead: Boolean?, lastPageRead: Int?) {
+        transaction {
+            if (listOf(isRead, isBookmarked, lastPageRead).any { it != null }) {
+                EpisodeTable.update({ (EpisodeTable.anime eq animeId) and (EpisodeTable.episodeIndex eq episodeIndex) }) { update ->
+                    isRead?.also {
+                        update[EpisodeTable.isRead] = it
+                    }
+                    isBookmarked?.also {
+                        update[EpisodeTable.isBookmarked] = it
+                    }
+                    lastPageRead?.also {
+                        update[EpisodeTable.lastPageRead] = it
+                    }
+                }
+            }
+
+            markPrevRead?.let {
+                EpisodeTable.update({ (EpisodeTable.anime eq animeId) and (EpisodeTable.episodeIndex less episodeIndex) }) {
+                    it[EpisodeTable.isRead] = markPrevRead
+                }
+            }
+        }
+    }
+}
--- a/server/src/main/kotlin/suwayomi/anime/impl/Source.kt
+++ b/server/src/main/kotlin/suwayomi/anime/impl/Source.kt
@@ -0,0 +1,50 @@
+package suwayomi.anime.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 mu.KotlinLogging
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.selectAll
+import org.jetbrains.exposed.sql.transactions.transaction
+import suwayomi.anime.impl.extension.Extension.getExtensionIconUrl
+import suwayomi.anime.impl.util.GetAnimeHttpSource.getAnimeHttpSource
+import suwayomi.anime.model.dataclass.AnimeSourceDataClass
+import suwayomi.anime.model.table.AnimeExtensionTable
+import suwayomi.anime.model.table.AnimeSourceTable
+
+object Source {
+    private val logger = KotlinLogging.logger {}
+
+    fun getSourceList(): List<AnimeSourceDataClass> {
+        return transaction {
+            AnimeSourceTable.selectAll().map {
+                AnimeSourceDataClass(
+                    it[AnimeSourceTable.id].value.toString(),
+                    it[AnimeSourceTable.name],
+                    it[AnimeSourceTable.lang],
+                    getExtensionIconUrl(AnimeExtensionTable.select { AnimeExtensionTable.id eq it[AnimeSourceTable.extension] }.first()[AnimeExtensionTable.apkName]),
+                    getAnimeHttpSource(it[AnimeSourceTable.id].value).supportsLatest
+                )
+            }
+        }
+    }
+
+    fun getAnimeSource(sourceId: Long): AnimeSourceDataClass {
+        return transaction {
+            val source = AnimeSourceTable.select { AnimeSourceTable.id eq sourceId }.firstOrNull()
+
+            AnimeSourceDataClass(
+                sourceId.toString(),
+                source?.get(AnimeSourceTable.name),
+                source?.get(AnimeSourceTable.lang),
+                source?.let { AnimeExtensionTable.select { AnimeExtensionTable.id eq source[AnimeSourceTable.extension] }.first()[AnimeExtensionTable.iconUrl] },
+                source?.let { getAnimeHttpSource(sourceId).supportsLatest }
+            )
+        }
+    }
+}
--- a/server/src/main/kotlin/suwayomi/anime/impl/util/GetAnimeHttpSource.kt
+++ b/server/src/main/kotlin/suwayomi/anime/impl/util/GetAnimeHttpSource.kt
@@ -0,0 +1,57 @@
+package suwayomi.anime.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.AnimeSource
+import eu.kanade.tachiyomi.source.AnimeSourceFactory
+import eu.kanade.tachiyomi.source.online.AnimeHttpSource
+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 suwayomi.anime.impl.util.PackageTools.loadExtensionSources
+import suwayomi.anime.model.table.AnimeExtensionTable
+import suwayomi.anime.model.table.AnimeSourceTable
+import suwayomi.server.ApplicationDirs
+import java.util.concurrent.ConcurrentHashMap
+
+object GetAnimeHttpSource {
+    private val sourceCache = ConcurrentHashMap<Long, AnimeHttpSource>()
+    private val applicationDirs by DI.global.instance<ApplicationDirs>()
+
+    fun getAnimeHttpSource(sourceId: Long): AnimeHttpSource {
+        val cachedResult: AnimeHttpSource? = sourceCache[sourceId]
+        if (cachedResult != null) {
+            return cachedResult
+        }
+
+        val sourceRecord = transaction {
+            AnimeSourceTable.select { AnimeSourceTable.id eq sourceId }.first()
+        }
+
+        val extensionId = sourceRecord[AnimeSourceTable.extension]
+        val extensionRecord = transaction {
+            AnimeExtensionTable.select { AnimeExtensionTable.id eq extensionId }.first()
+        }
+
+        val apkName = extensionRecord[AnimeExtensionTable.apkName]
+        val className = extensionRecord[AnimeExtensionTable.classFQName]
+        val jarName = apkName.substringBefore(".apk") + ".jar"
+        val jarPath = "${applicationDirs.extensionsRoot}/$jarName"
+
+        when (val instance = loadExtensionSources(jarPath, className)) {
+            is AnimeSource -> listOf(instance)
+            is AnimeSourceFactory -> instance.createSources()
+            else -> throw Exception("Unknown source class type! ${instance.javaClass}")
+        }.forEach {
+            sourceCache[it.id] = it as AnimeHttpSource
+        }
+        return sourceCache[sourceId]!!
+    }
+}
--- a/server/src/main/kotlin/suwayomi/anime/model/dataclass/AnimeDataClass.kt
+++ b/server/src/main/kotlin/suwayomi/anime/model/dataclass/AnimeDataClass.kt
@@ -0,0 +1,36 @@
+package suwayomi.anime.model.dataclass
+
+/*
+ * 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 suwayomi.anime.model.table.AnimeStatus
+
+data class AnimeDataClass(
+    val id: Int,
+    val sourceId: String,
+
+    val url: String,
+    val title: String,
+    val thumbnailUrl: String? = null,
+
+    val initialized: Boolean = false,
+
+    val artist: String? = null,
+    val author: String? = null,
+    val description: String? = null,
+    val genre: String? = null,
+    val status: String = AnimeStatus.UNKNOWN.name,
+    val inLibrary: Boolean = false,
+    val source: AnimeSourceDataClass? = null,
+
+    val freshData: Boolean = false
+)
+
+data class PagedAnimeListDataClass(
+    val mangaList: List<AnimeDataClass>,
+    val hasNextPage: Boolean
+)
--- a/server/src/main/kotlin/suwayomi/anime/model/dataclass/EpisodeDataClass.kt
+++ b/server/src/main/kotlin/suwayomi/anime/model/dataclass/EpisodeDataClass.kt
@@ -0,0 +1,35 @@
+package suwayomi.anime.model.dataclass
+
+/*
+ * 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 EpisodeDataClass(
+    val url: String,
+    val name: String,
+    val uploadDate: Long,
+    val episodeNumber: Float,
+    val scanlator: String?,
+    val animeId: Int,
+
+    /** chapter is read */
+    val read: Boolean,
+
+    /** chapter is bookmarked */
+    val bookmarked: Boolean,
+
+    /** last read page, zero means not read/no data */
+    val lastPageRead: Int,
+
+    /** this chapter's index, starts with 1 */
+    val index: Int,
+
+    /** 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,
+)
--- a/server/src/main/kotlin/suwayomi/anime/model/table/AnimeTable.kt
+++ b/server/src/main/kotlin/suwayomi/anime/model/table/AnimeTable.kt
@@ -0,0 +1,65 @@
+package suwayomi.anime.model.table
+
+/*
+ * 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.SAnime
+import org.jetbrains.exposed.dao.id.IntIdTable
+import org.jetbrains.exposed.sql.ResultRow
+import suwayomi.tachidesk.impl.MangaList.proxyThumbnailUrl
+import suwayomi.tachidesk.model.dataclass.MangaDataClass
+import suwayomi.tachidesk.model.table.MangaStatus.Companion
+
+object AnimeTable : IntIdTable() {
+    val url = varchar("url", 2048)
+    val title = varchar("title", 512)
+    val initialized = bool("initialized").default(false)
+
+    val artist = varchar("artist", 64).nullable()
+    val author = varchar("author", 64).nullable()
+    val description = varchar("description", 4096).nullable()
+    val genre = varchar("genre", 1024).nullable()
+
+    val status = integer("status").default(SAnime.UNKNOWN)
+    val thumbnail_url = varchar("thumbnail_url", 2048).nullable()
+
+    val inLibrary = bool("in_library").default(false)
+    val defaultCategory = bool("default_category").default(true)
+
+    // source is used by some ancestor of IntIdTable
+    val sourceReference = long("source")
+}
+
+fun AnimeTable.toDataClass(mangaEntry: ResultRow) =
+    MangaDataClass(
+        mangaEntry[this.id].value,
+        mangaEntry[sourceReference].toString(),
+
+        mangaEntry[url],
+        mangaEntry[title],
+        proxyThumbnailUrl(mangaEntry[this.id].value),
+
+        mangaEntry[initialized],
+
+        mangaEntry[artist],
+        mangaEntry[author],
+        mangaEntry[description],
+        mangaEntry[genre],
+        Companion.valueOf(mangaEntry[status]).name,
+        mangaEntry[inLibrary]
+    )
+
+enum class AnimeStatus(val status: Int) {
+    UNKNOWN(0),
+    ONGOING(1),
+    COMPLETED(2),
+    LICENSED(3);
+
+    companion object {
+        fun valueOf(value: Int): AnimeStatus = values().find { it.status == value } ?: UNKNOWN
+    }
+}
--- a/server/src/main/kotlin/suwayomi/anime/model/table/EpisodeTable.kt
+++ b/server/src/main/kotlin/suwayomi/anime/model/table/EpisodeTable.kt
@@ -0,0 +1,43 @@
+package suwayomi.anime.model.table
+
+/*
+ * 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.jetbrains.exposed.dao.id.IntIdTable
+import org.jetbrains.exposed.sql.ResultRow
+import suwayomi.anime.model.dataclass.EpisodeDataClass
+
+object EpisodeTable : IntIdTable() {
+    val url = varchar("url", 2048)
+    val name = varchar("name", 512)
+    val date_upload = long("date_upload").default(0)
+    val episode_number = float("episode_number").default(-1f)
+    val scanlator = varchar("scanlator", 128).nullable()
+
+    val isRead = bool("read").default(false)
+    val isBookmarked = bool("bookmark").default(false)
+    val lastPageRead = integer("last_page_read").default(0)
+
+    // index is reserved by a function
+    val episodeIndex = integer("index")
+
+    val anime = reference("anime", AnimeTable)
+}
+
+fun EpisodeTable.toDataClass(episodeEntry: ResultRow) =
+    EpisodeDataClass(
+        episodeEntry[url],
+        episodeEntry[name],
+        episodeEntry[date_upload],
+        episodeEntry[episode_number],
+        episodeEntry[scanlator],
+        episodeEntry[anime].value,
+        episodeEntry[isRead],
+        episodeEntry[isBookmarked],
+        episodeEntry[lastPageRead],
+        episodeEntry[episodeIndex],
+    )
--- a/server/src/main/kotlin/suwayomi/server/ServerSetup.kt
+++ b/server/src/main/kotlin/suwayomi/server/ServerSetup.kt
@@ -29,7 +29,8 @@ class ApplicationDirs(
    val dataRoot: String = ApplicationRootDir
 ) {
    val extensionsRoot = "$dataRoot/extensions"
-    val thumbnailsRoot = "$dataRoot/thumbnails"
+    val mangaThumbnailsRoot = "$dataRoot/manga-thumbnails"
+    val animeThumbnailsRoot = "$dataRoot/anime-thumbnails"
    val mangaRoot = "$dataRoot/manga"
 }

@@ -55,7 +56,8 @@ fun applicationSetup() {
        applicationDirs.dataRoot,
        applicationDirs.extensionsRoot,
        applicationDirs.extensionsRoot + "/icon",
-        applicationDirs.thumbnailsRoot
+        applicationDirs.mangaThumbnailsRoot,
+        applicationDirs.animeThumbnailsRoot,
    ).forEach {
        File(it).mkdirs()
    }
--- a/server/src/main/kotlin/suwayomi/server/database/migration/M0005_AnimeTablesBatch2.kt
+++ b/server/src/main/kotlin/suwayomi/server/database/migration/M0005_AnimeTablesBatch2.kt
@@ -0,0 +1,45 @@
+package suwayomi.server.database.migration
+
+import eu.kanade.tachiyomi.source.model.SAnime
+import org.jetbrains.exposed.dao.id.IntIdTable
+import org.jetbrains.exposed.sql.SchemaUtils
+import org.jetbrains.exposed.sql.transactions.transaction
+import suwayomi.server.database.migration.lib.Migration
+
+/*
+ * 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/. */
+
+class M0005_AnimeTablesBatch2 : Migration() {
+    private object AnimeTable : IntIdTable() {
+        val url = varchar("url", 2048)
+        val title = varchar("title", 512)
+        val initialized = bool("initialized").default(false)
+
+        val artist = varchar("artist", 64).nullable()
+        val author = varchar("author", 64).nullable()
+        val description = varchar("description", 4096).nullable()
+        val genre = varchar("genre", 1024).nullable()
+
+        //    val status = enumeration("status", MangaStatus::class).default(MangaStatus.UNKNOWN)
+        val status = integer("status").default(SAnime.UNKNOWN)
+        val thumbnail_url = varchar("thumbnail_url", 2048).nullable()
+
+        val inLibrary = bool("in_library").default(false)
+        val defaultCategory = bool("default_category").default(true)
+
+        // source is used by some ancestor of IntIdTable
+        val sourceReference = long("source")
+    }
+
+    override fun run() {
+        transaction {
+            SchemaUtils.create(
+                AnimeTable
+            )
+        }
+    }
+}
--- a/server/src/main/kotlin/suwayomi/server/database/migration/M0006_AnimeTablesBatch3.kt
+++ b/server/src/main/kotlin/suwayomi/server/database/migration/M0006_AnimeTablesBatch3.kt
@@ -0,0 +1,41 @@
+package suwayomi.server.database.migration
+
+import org.jetbrains.exposed.dao.id.IntIdTable
+import org.jetbrains.exposed.sql.SchemaUtils
+import org.jetbrains.exposed.sql.transactions.transaction
+import suwayomi.anime.model.table.AnimeTable
+import suwayomi.server.database.migration.lib.Migration
+
+/*
+ * 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/. */
+
+class M0006_AnimeTablesBatch3 : Migration() {
+    private object EpisodeTable : IntIdTable() {
+        val url = varchar("url", 2048)
+        val name = varchar("name", 512)
+        val date_upload = long("date_upload").default(0)
+        val episode_number = float("episode_number").default(-1f)
+        val scanlator = varchar("scanlator", 128).nullable()
+
+        val isRead = bool("read").default(false)
+        val isBookmarked = bool("bookmark").default(false)
+        val lastPageRead = integer("last_page_read").default(0)
+
+        // index is reserved by a function
+        val animeIndex = integer("index")
+
+        val anime = reference("anime", AnimeTable)
+    }
+
+    override fun run() {
+        transaction {
+            SchemaUtils.create(
+                EpisodeTable
+            )
+        }
+    }
+}
--- a/server/src/main/kotlin/suwayomi/tachidesk/impl/Manga.kt
+++ b/server/src/main/kotlin/suwayomi/tachidesk/impl/Manga.kt
@@ -111,7 +111,7 @@ object Manga {

    private val applicationDirs by DI.global.instance<ApplicationDirs>()
    suspend fun getMangaThumbnail(mangaId: Int): Pair<InputStream, String> {
-        val saveDir = applicationDirs.thumbnailsRoot
+        val saveDir = applicationDirs.mangaThumbnailsRoot
        val fileName = mangaId.toString()

        return getCachedImageResponse(saveDir, fileName) {
@@ -131,7 +131,7 @@ object Manga {
    }

    private fun clearMangaThumbnail(mangaId: Int) {
-        val saveDir = applicationDirs.thumbnailsRoot
+        val saveDir = applicationDirs.mangaThumbnailsRoot
        val fileName = mangaId.toString()

        clearCachedImage(saveDir, fileName)
--- a/server/src/main/kotlin/suwayomi/tachidesk/model/table/MangaTable.kt
+++ b/server/src/main/kotlin/suwayomi/tachidesk/model/table/MangaTable.kt
@@ -24,7 +24,6 @@ object MangaTable : IntIdTable() {
    val description = varchar("description", 4096).nullable()
    val genre = varchar("genre", 1024).nullable()

-    //    val status = enumeration("status", MangaStatus::class).default(MangaStatus.UNKNOWN)
    val status = integer("status").default(SManga.UNKNOWN)
    val thumbnail_url = varchar("thumbnail_url", 2048).nullable()