Add Zenko

src/uk/zenko/build.gradle

@@ -0,0 +1,8 @@
+ext {
+    extName = 'Zenko'
+    extClass = '.Zenko'
+    extVersionCode = 1
+    isNsfw = true
+}
+
+apply from: "$rootDir/common.gradle"

src/uk/zenko/src/eu/kanade/tachiyomi/extension/uk/zenko/StringProcessor.kt

@@ -0,0 +1,89 @@
+package eu.kanade.tachiyomi.extension.uk.zenko
+
+import android.util.Log
+
+object StringProcessor {
+    private const val separator = "@#%&;№%#&**#!@"
+
+    data class ParsedResult(
+        val part: String = "",
+        val chapter: String = "",
+        val name: String = "",
+    )
+
+    fun parse(input: String?): ParsedResult {
+        if (input.isNullOrEmpty()) {
+            return ParsedResult()
+        }
+
+        val parts = input.split(separator)
+        return when (parts.size) {
+            3 -> {
+                val (part, chapter, name) = parts
+                ParsedResult(part, chapter, name)
+            }
+
+            2 -> {
+                val (part, chapter) = parts
+                ParsedResult(part, chapter)
+            }
+
+            1 -> {
+                val (name) = parts
+                ParsedResult(name = name)
+            }
+
+            else -> ParsedResult()
+        }
+    }
+
+    fun assemble(parsed: ParsedResult): String {
+        return listOf(parsed.part, parsed.chapter, parsed.name)
+            .filter { it.isNotEmpty() }
+            .joinToString(separator)
+    }
+
+    // gen ID by rule: part + chapter
+    // example
+    // 1 + 0 = 100
+    // 1 + 1 = 101
+    // 0 + 10 = 010
+    // 1 + 99 = 199
+    // 1 + 100.5 = 1100.5
+    fun generateId(input: String?): Double {
+        if (input.isNullOrEmpty()) {
+            return -1.0
+        }
+        val (part, chapter) = parse(input)
+
+        val partNumber = part.toIntOrNull() ?: 0
+        val chapterNumber = chapter.toDoubleOrNull() ?: 0
+
+        val idString = if (partNumber > 0) {
+            "$partNumber${ if (chapter.length == 1) chapter.padStart(2, '0') else chapter}"
+        } else {
+            "$chapterNumber"
+        }
+
+        return try {
+            idString.toDouble()
+        } catch (e: NumberFormatException) {
+            Log.d("ZENKO", "Invalid ID format: $idString")
+            -1.0
+        }
+    }
+
+    fun format(input: String?): String {
+        val (part, chapter, name) = parse(input)
+        val chapterLabel = if (chapter.isNotEmpty()) {
+            "Розділ $chapter${if (name.isNotEmpty()) ":" else ""}"
+        } else {
+            ""
+        }
+        return listOf(
+            if (part.isNotEmpty()) "Том $part" else "",
+            chapterLabel,
+            name,
+        ).filter { it.isNotEmpty() }.joinToString(" ")
+    }
+}

src/uk/zenko/src/eu/kanade/tachiyomi/extension/uk/zenko/Zenko.kt

@@ -0,0 +1,199 @@
+package eu.kanade.tachiyomi.extension.uk.zenko
+
+import eu.kanade.tachiyomi.extension.uk.zenko.dtos.ChapterResponseItem
+import eu.kanade.tachiyomi.extension.uk.zenko.dtos.MangaDetailsResponse
+import eu.kanade.tachiyomi.extension.uk.zenko.dtos.ZenkoMangaListResponse
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.interceptor.rateLimitHost
+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.source.online.HttpSource
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.decodeFromStream
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.Request
+import okhttp3.Response
+
+class Zenko : HttpSource() {
+    override val name = "Zenko"
+    override val baseUrl = "https://zenko.online"
+    override val lang = "uk"
+    override val supportsLatest = true
+
+    override fun headersBuilder() = super.headersBuilder()
+        .add("Origin", baseUrl)
+        .add("Referer", baseUrl)
+
+    override val client = network.client.newBuilder()
+        .rateLimitHost(API_URL.toHttpUrl(), 10)
+        .build()
+
+    // ============================== Popular ===============================
+    override fun popularMangaRequest(page: Int): Request {
+        val offset = offsetCounter(page)
+        return makeZenkoMangaRequest(offset, "viewsCount")
+    }
+
+    override fun popularMangaParse(response: Response) = parseAsMangaResponseDto(response)
+
+    // =============================== Latest ===============================
+    override fun latestUpdatesRequest(page: Int): Request {
+        val offset = offsetCounter(page)
+        return makeZenkoMangaRequest(offset, "lastChapterCreatedAt")
+    }
+
+    override fun latestUpdatesParse(response: Response) = parseAsMangaResponseDto(response)
+
+    // =============================== Search ===============================
+    override fun searchMangaRequest(page: Int, query: String, filters: FilterList): Request {
+        if (query.length >= 2) {
+            val offset = offsetCounter(page)
+            val url = "$API_URL/titles".toHttpUrl().newBuilder()
+                .addQueryParameter("limit", "15")
+                .addQueryParameter("offset", "$offset")
+                .addQueryParameter("name", query)
+                .build()
+            return GET(url, headers)
+        } else {
+            throw UnsupportedOperationException("Запит має містити щонайменше 2 символи / The query must contain at least 2 characters")
+        }
+    }
+
+    override fun searchMangaParse(response: Response) = parseAsMangaResponseDto(response)
+
+    // =========================== Manga Details ============================
+    override fun mangaDetailsRequest(manga: SManga): Request {
+        val mangaId = manga.url.substringAfterLast('/')
+        val url = "$API_URL/titles/$mangaId"
+        return GET(url, headers)
+    }
+
+    override fun mangaDetailsParse(response: Response) = SManga.create().apply {
+        val mangaDto = response.asClass<MangaDetailsResponse>()
+        title = mangaDto.engName ?: mangaDto.name
+        thumbnail_url =
+            "$IMAGE_STORAGE_URL/${mangaDto.coverImg}?optimizer=image&width=560&quality=70&height=auto"
+        url = "$baseUrl/titles/${mangaDto.id}"
+        description = "${mangaDto.name}\n${mangaDto.description}"
+        genre = mangaDto.genres!!.joinToString { it.name }
+        author = mangaDto.author!!.username
+        status = mangaDto.status.toStatus()
+    }
+
+    // ============================== Chapters ==============================
+    override fun chapterListRequest(manga: SManga): Request {
+        val mangaId = manga.url.substringAfterLast('/')
+        val url = "$API_URL/titles/$mangaId/chapters"
+        return GET(url, headers)
+    }
+
+    override fun chapterListParse(response: Response): List<SChapter> {
+        val result = response.asClass<List<ChapterResponseItem>>()
+        return result.sortedByDescending { item ->
+            val id = StringProcessor.generateId(item.name)
+            if (id > 0) id else item.id.toDouble()
+        }.map { chapterResponseItem ->
+            SChapter.create().apply {
+                url = "$baseUrl/titles/${chapterResponseItem.titleId}/${chapterResponseItem.id}"
+                name = StringProcessor.format(chapterResponseItem.name)
+                date_upload = chapterResponseItem.createdAt!!.secToMs()
+                scanlator = chapterResponseItem.publisher!!.name
+            }
+        }
+    }
+
+    // =============================== Pages ================================
+    override fun pageListRequest(chapter: SChapter): Request {
+        val chapterId = chapter.url.substringAfterLast('/')
+        val url = "$API_URL/chapters/$chapterId"
+        return GET(url, headers)
+    }
+
+    override fun pageListParse(response: Response): List<Page> {
+        val data = response.asClass<ChapterResponseItem>()
+        return data.pages!!.map { page ->
+            Page(page.id, "", "$IMAGE_STORAGE_URL/${page.imgUrl}")
+        }
+    }
+
+    override fun imageUrlParse(response: Response): String = ""
+
+    // ============================= Utilities ==============================
+    private fun parseAsMangaResponseDto(response: Response): MangasPage {
+        val zenkoMangaListResponse = response.asClass<ZenkoMangaListResponse>()
+        return makeMangasPage(zenkoMangaListResponse.data, zenkoMangaListResponse.meta.hasNextPage)
+    }
+
+    private fun offsetCounter(page: Int): Int {
+        var currentOfsset = 0
+        val offset = if (page == 1) {
+            currentOfsset = 0 // for page 1 offset must be 0
+            currentOfsset
+        } else {
+            currentOfsset = (page - 1) * 15 // calculate offset for other pages
+            currentOfsset
+        }
+        return offset
+    }
+
+    private fun makeZenkoMangaRequest(offset: Int, sortBy: String): Request {
+        val url = "$API_URL/titles".toHttpUrl().newBuilder()
+            .addQueryParameter("limit", "15")
+            .addQueryParameter("offset", "$offset")
+            .addQueryParameter("sortBy", sortBy)
+            .addQueryParameter("order", "DESC")
+            .build()
+        return GET(url, headers)
+    }
+
+    private fun makeMangasPage(
+        mangaList: List<MangaDetailsResponse>?,
+        hasNextPage: Boolean = false,
+    ): MangasPage {
+        return MangasPage(
+            mangaList!!.map(::makeSManga),
+            hasNextPage,
+        )
+    }
+
+    private fun makeSManga(mangaDto: MangaDetailsResponse) = SManga.create().apply {
+        title = mangaDto.engName ?: mangaDto.name
+        thumbnail_url =
+            "$IMAGE_STORAGE_URL/${mangaDto.coverImg}?optimizer=image&width=560&quality=70&height=auto"
+        url = "$baseUrl/titles/${mangaDto.id}"
+        status = mangaDto.status.toStatus()
+    }
+
+    private fun String.toStatus(): Int {
+        return when (this) {
+            "ONGOING" -> SManga.ONGOING
+            "FINISHED" -> SManga.COMPLETED
+            "PAUSED" -> SManga.ON_HIATUS
+            else -> SManga.UNKNOWN
+        }
+    }
+
+    private fun Long.secToMs(): Long {
+        return (
+            runCatching { this * 1000 }
+                .getOrNull() ?: 0L
+            )
+    }
+
+    companion object {
+        private const val API_URL = "https://zenko-api.onrender.com"
+        private const val IMAGE_STORAGE_URL = "https://zenko.b-cdn.net"
+
+        private val json = Json {
+            ignoreUnknownKeys = true
+            coerceInputValues = true
+        }
+
+        private inline fun <reified T> Response.asClass(): T = use {
+            json.decodeFromStream(it.body.byteStream())
+        }
+    }
+}