[CuuTruyen] Fixes

src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/rulib/HentaiLibParser.kt

@@ -1,10 +1,12 @@
 package org.koitharu.kotatsu.parsers.site.ru.rulib
 
+import org.koitharu.kotatsu.parsers.Broken
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.MangaSourceParser
 import org.koitharu.kotatsu.parsers.model.ContentType
 import org.koitharu.kotatsu.parsers.model.MangaParserSource
 
+@Broken
 @MangaSourceParser("HENTAILIB", "HentaiLib", "ru", type = ContentType.HENTAI)
 internal class HentaiLibParser(context: MangaLoaderContext) : LibSocialParser(
 	context = context,

src/main/kotlin/org/koitharu/kotatsu/parsers/site/vi/CuuTruyenParser.kt

@@ -1,5 +1,7 @@
 package org.koitharu.kotatsu.parsers.site.vi
 
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
 import okhttp3.Headers
 import okhttp3.Interceptor
 import okhttp3.Response
@@ -9,173 +11,184 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser
 import org.koitharu.kotatsu.parsers.PagedMangaParser
 import org.koitharu.kotatsu.parsers.config.ConfigKey
 import org.koitharu.kotatsu.parsers.model.*
+import org.koitharu.kotatsu.parsers.network.UserAgents
 import org.koitharu.kotatsu.parsers.util.*
 import org.koitharu.kotatsu.parsers.util.json.*
-import org.koitharu.kotatsu.parsers.exception.ParseException
-import org.koitharu.kotatsu.parsers.network.UserAgents
 import java.io.ByteArrayOutputStream
 import java.text.SimpleDateFormat
 import java.util.*
 import java.util.zip.Inflater
 
 @MangaSourceParser("CUUTRUYEN", "CuuTruyen", "vi")
-internal class CuuTruyenParser(context: MangaLoaderContext) : PagedMangaParser(context, MangaParserSource.CUUTRUYEN, 20), Interceptor {
+internal class CuuTruyenParser(context: MangaLoaderContext) :
-
+	PagedMangaParser(context, MangaParserSource.CUUTRUYEN, 20), Interceptor {
-    override val configKeyDomain = ConfigKey.Domain("cuutruyen.net", "nettrom.com", "hetcuutruyen.net", "cuutruyent9sv7.xyz")
+
-
+	override val configKeyDomain =
-    override val availableSortOrders: Set<SortOrder> = EnumSet.of(
+		ConfigKey.Domain("cuutruyen.net", "nettrom.com", "hetcuutruyen.net", "cuutruyent9sv7.xyz")
-        SortOrder.UPDATED,
+
-        SortOrder.POPULARITY,
+	override val availableSortOrders: Set<SortOrder> = EnumSet.of(
-        SortOrder.NEWEST,
+		SortOrder.UPDATED,
-    )
+		SortOrder.POPULARITY,
-
+		SortOrder.NEWEST,
-    override fun getRequestHeaders(): Headers = Headers.Builder()
+	)
-        .add("User-Agent", UserAgents.KOTATSU)
+
-        .build()
+	override fun getRequestHeaders(): Headers = Headers.Builder()
-
+		.add("User-Agent", UserAgents.KOTATSU)
-    private val decryptionKey = "3141592653589793"
+		.build()
-    private val itemsPerPage: Int = 20
+
-
+	private val decryptionKey = "3141592653589793"
-    override suspend fun getAvailableTags(): Set<MangaTag> = emptySet()
+	private val itemsPerPage: Int = 20
-
+
-    private suspend fun getListPage(
+	override suspend fun getAvailableTags(): Set<MangaTag> = emptySet()
-        offset: Int,
+
-        query: String?,
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
-        tags: Set<MangaTag>?,
+		val url = buildString {
-        sortOrder: SortOrder,
+			append("https://")
-    ): List<Manga> {
+			append(domain)
-        val page = offset / itemsPerPage + 1
+			when (filter) {
-        val url = buildString {
+				is MangaListFilter.Search -> {
-            if (!query.isNullOrEmpty()) {
+					append("/api/v2/mangas/search?q=")
-                append("$domain/api/v2/mangas/search")
+					append(filter.query.urlEncoded())
-                append("?q=")
+					append("&page=")
-                append(query.urlEncoded())
+					append(page.toString())
-                append("&page=")
+				}
-                append(page.toString())
+
-                append("&per_page=")
+				else -> {
-                append(itemsPerPage.toString())
+					val tag = (filter as? MangaListFilter.Advanced)?.tags?.oneOrThrowIfMany()
-            } else {
+					if (tag != null) {
-                append("$domain/api/v2/mangas")
+						append("/api/v2/tags/")
-                when (sortOrder) {
+						append(tag.key)
-                    SortOrder.UPDATED -> append("/recently_updated")
+					} else {
-                    SortOrder.POPULARITY -> append("/top")
+						append("/api/v2/mangas")
-                    SortOrder.NEWEST -> append("/recently_updated")
+						when (filter?.sortOrder) {
-                    else -> append("/recently_updated")
+							SortOrder.UPDATED -> append("/recently_updated")
-                }
+							SortOrder.POPULARITY -> append("/top")
-                append("?page=")
+							SortOrder.NEWEST -> append("/recently_updated")
-                append(page.toString())
+							else -> append("/recently_updated")
-            }
+						}
-        }
+					}
-
+					append("?page=")
-        val json = webClient.httpGet(url).parseJson()
+					append(page.toString())
-        val data = json.optJSONObject("data") ?: throw ParseException("Invalid response", url)
+				}
-
+			}
-        return data.getJSONArray("data").mapJSON { jo ->
+
-            Manga(
+			append("&per_page=")
-                id = generateUid(jo.getLong("id")),
+			append(itemsPerPage)
-                url = "/api/v2/mangas/${jo.getLong("id")}",
+		}
-                publicUrl = "$domain/manga/${jo.getLong("id")}",
+
-                title = jo.getString("name"),
+		val json = webClient.httpGet(url).parseJson()
-                altTitle = null,
+		val data = json.getJSONArray("data")
-                coverUrl = jo.getString("cover_url"),
+
-                largeCoverUrl = jo.getString("cover_mobile_url"),
+		return data.mapJSON { jo ->
-                author = jo.getStringOrNull("author_name"),
+			Manga(
-                tags = emptySet(),
+				id = generateUid(jo.getLong("id")),
-                state = null,
+				url = "/api/v2/mangas/${jo.getLong("id")}",
-                description = null,
+				publicUrl = "https://$domain/manga/${jo.getLong("id")}",
-                isNsfw = false,
+				title = jo.getString("name"),
-                source = source,
+				altTitle = null,
-                rating = RATING_UNKNOWN,
+				coverUrl = jo.getString("cover_url"),
-            )
+				largeCoverUrl = jo.getString("cover_mobile_url"),
-        }
+				author = jo.getStringOrNull("author_name"),
-    }
+				tags = emptySet(),
-
+				state = null,
-    override suspend fun getDetails(manga: Manga): Manga {
+				description = null,
-        val url = domain + manga.url
+				isNsfw = isNsfwSource,
-        val json = webClient.httpGet(url).parseJson().getJSONObject("data")
+				source = source,
-            ?: throw ParseException("Invalid response", url)
+				rating = RATING_UNKNOWN,
-
+			)
-        return manga.copy(
+		}
-            description = json.getString("description"),
+	}
-            chapters = json.getJSONArray("chapters").mapJSON { jo ->
+
-                MangaChapter(
+	override suspend fun getDetails(manga: Manga): Manga = coroutineScope {
-                    id = generateUid(jo.getLong("id")),
+		val url = "https://" + domain + manga.url
-                    name = jo.getString("name"),
+		val chapters = async {
-                    number = jo.getInt("number"),
+			webClient.httpGet("$url/chapters").parseJson().getJSONArray("data")
-                    url = "/api/v2/chapters/${jo.getLong("id")}",
+		}
-                    scanlator = jo.optString("group_name"),
+		val json = webClient.httpGet(url).parseJson().getJSONObject("data")
-                    uploadDate = parseChapterDate(jo.getString("created_at")),
+		val chapterDateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US)
-                    branch = null,
+
-                    source = source,
+		manga.copy(
-                )
+			title = json.getStringOrNull("name") ?: manga.title,
-            }.reversed(),
+			isNsfw = json.getBooleanOrDefault("is_nsfw", manga.isNsfw),
-        )
+			author = json.optJSONObject("author")?.getStringOrNull("name")?.substringBefore(','),
-    }
+			description = json.getString("full_description"),
-
+			tags = json.optJSONArray("tags")?.mapJSONToSet { jo ->
-    override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
+				MangaTag(
-        val url = "$domain${chapter.url}"
+					title = jo.getString("name").toTitleCase(sourceLocale),
-        val json = webClient.httpGet(url).parseJson().getJSONObject("data")
+					key = jo.getString("slug"),
-            ?: throw ParseException("Invalid response", url)
+					source = source,
-
+				)
-        return json.getJSONArray("pages").mapJSON { jo ->
+			}.orEmpty(),
-            val imageUrl = jo.getString("image_url")
+			chapters = chapters.await().mapJSON { jo ->
-            MangaPage(
+				val chapterId = jo.getLong("id")
-                id = generateUid(jo.getLong("id")),
+				val number = jo.getFloatOrDefault("number", 0f)
-                url = imageUrl,
+				MangaChapter(
-                preview = null,
+					id = generateUid(chapterId),
-                source = source,
+					name = jo.getStringOrNull("name") ?: number.formatSimple(),
-            )
+					number = number,
-        }
+					volume = 0,
-    }
+					url = "/api/v2/chapters/$chapterId",
-
+					scanlator = jo.optString("group_name"),
-    override fun intercept(chain: Interceptor.Chain): Response {
+					uploadDate = chapterDateFormat.tryParse(jo.getStringOrNull("created_at")),
-        val request = chain.request()
+					branch = null,
-        val response = chain.proceed(request)
+					source = source,
-
+				)
-        if (!request.url.host.contains("cuutruyen.net")) {
+			}.reversed(),
-            return response
+		)
-        }
+	}
-
+
-        val body = response.body ?: return response
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
-        val contentType = body.contentType()
+		val url = "https://$domain${chapter.url}"
-        val bytes = body.bytes()
+		val json = webClient.httpGet(url).parseJson().getJSONObject("data")
-
+
-        val decrypted = try {
+		return json.getJSONArray("pages").mapJSON { jo ->
-            decrypt(bytes)
+			val imageUrl = jo.getString("image_url")
-        } catch (e: Exception) {
+			MangaPage(
-            bytes
+				id = generateUid(jo.getLong("id")),
-        }
+				url = imageUrl,
-
+				preview = null,
-        val decompressed = try {
+				source = source,
-            decompress(decrypted)
+			)
-        } catch (e: Exception) {
+		}
-            decrypted
+	}
-        }
+
-
+	override fun intercept(chain: Interceptor.Chain): Response {
-        val newBody = decompressed.toResponseBody(contentType)
+		val request = chain.request()
-        return response.newBuilder().body(newBody).build()
+		val response = chain.proceed(request)
-    }
+
-
+		if (!request.url.host.contains(domain, ignoreCase = true)) {
-    private fun decrypt(input: ByteArray): ByteArray {
+			return response
-        val key = decryptionKey.toByteArray()
+		}
-        return input.mapIndexed { index, byte ->
+
-            (byte.toInt() xor key[index % key.size].toInt()).toByte()
+		val body = response.body ?: return response
-        }.toByteArray()
+		val contentType = body.contentType()
-    }
+		val bytes = body.bytes()
-
+
-    private fun decompress(input: ByteArray): ByteArray {
+		val decrypted = try {
-        val inflater = Inflater()
+			decompress(decrypt(bytes))
-        inflater.setInput(input, 0, input.size)
+		} catch (e: Exception) {
-        val outputStream = ByteArrayOutputStream(input.size)
+			bytes
-        val buffer = ByteArray(1024)
+		}
-        while (!inflater.finished()) {
+		val newBody = decrypted.toResponseBody(contentType)
-            val count = inflater.inflate(buffer)
+		return response.newBuilder().body(newBody).build()
-            outputStream.write(buffer, 0, count)
+	}
-        }
+
-        return outputStream.toByteArray()
+	private fun decrypt(input: ByteArray): ByteArray {
-    }
+		val key = decryptionKey.toByteArray()
-
+		return input.mapIndexed { index, byte ->
-    private fun parseChapterDate(dateString: String): Long {
+			(byte.toInt() xor key[index % key.size].toInt()).toByte()
-        return SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US).parse(dateString)?.time ?: 0L
+		}.toByteArray()
-    }
+	}
+
+	private fun decompress(input: ByteArray): ByteArray {
+		val inflater = Inflater()
+		inflater.setInput(input, 0, input.size)
+		val outputStream = ByteArrayOutputStream(input.size)
+		val buffer = ByteArray(1024)
+		while (!inflater.finished()) {
+			val count = inflater.inflate(buffer)
+			outputStream.write(buffer, 0, count)
+		}
+		return outputStream.toByteArray()
+	}
 }