diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/ComickFunParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/ComickFunParser.kt index 0f50b4b54..7bca28a63 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/ComickFunParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/ComickFunParser.kt @@ -85,7 +85,7 @@ internal class ComickFunParser(context: MangaLoaderContext) : MangaParser(contex coverUrl = jo.getString("cover_url"), largeCoverUrl = null, description = jo.getStringOrNull("desc"), - tags = jo.selectGenres("genres", tagsMap), + tags = jo.selectGenres(tagsMap), state = runCatching { if (jo.getBoolean("translation_completed")) { MangaState.FINISHED @@ -203,8 +203,8 @@ internal class ComickFunParser(context: MangaLoaderContext) : MangaParser(contex return chaptersBuilder.toList() } - private fun JSONObject.selectGenres(name: String, tags: SparseArrayCompat): Set { - val array = optJSONArray(name) ?: return emptySet() + private fun JSONObject.selectGenres(tags: SparseArrayCompat): Set { + val array = optJSONArray("genres") ?: return emptySet() val res = ArraySet(array.length()) for (i in 0 until array.length()) { val id = array.getInt(i) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/HentaiFox.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/HentaiFox.kt new file mode 100644 index 000000000..c20e53fa5 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/HentaiFox.kt @@ -0,0 +1,179 @@ +package org.koitharu.kotatsu.parsers.site.all + +import androidx.collection.ArraySet +import kotlinx.coroutines.async +import kotlinx.coroutines.awaitAll +import kotlinx.coroutines.coroutineScope +import org.jsoup.nodes.Element +import org.koitharu.kotatsu.parsers.MangaLoaderContext +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.util.* +import java.util.* + +@MangaSourceParser("HENTAIFOX", "Hentai Fox", type = ContentType.HENTAI) +internal class HentaiFox(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.HENTAIFOX, 20) { + + override val sortOrders: Set = EnumSet.of(SortOrder.UPDATED) + override val configKeyDomain = ConfigKey.Domain("hentaifox.com") + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + val tag = tags.oneOrThrowIfMany() + + val url = buildString { + append("https://") + append(domain) + if (!tags.isNullOrEmpty()) { + append("/tag/") + append(tag?.key.orEmpty()) + if (page > 1) { + append("/pag/") + append(page) + append("/") + } + } else if (!query.isNullOrEmpty()) { + append("/search/?q=") + append(query.urlEncoded()) + if (page > 1) { + append("&page=") + append(page) + } + } else { + if (page > 2) { + append("/pag/") + append(page) + append("/") + } else if (page > 1) { + append("/page/") + append(page) + append("/") + } + } + } + val doc = webClient.httpGet(url).parseHtml() + return doc.select(".lc_galleries .thumb").map { div -> + val href = div.selectFirstOrThrow(".inner_thumb a").attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + title = div.select("h2.g_title").text(), + altTitle = null, + url = href, + publicUrl = href.toAbsoluteUrl(domain), + rating = RATING_UNKNOWN, + isNsfw = isNsfwSource, + coverUrl = div.selectFirstOrThrow("img").src().orEmpty(), + tags = emptySet(), + state = null, + author = null, + source = source, + ) + } + } + + //Tags are deliberately reduced because there are too many and this slows down the application. + //only the most popular ones are taken. + override suspend fun getTags(): Set { + return coroutineScope { + (1..3).map { page -> + async { getTags(page) } + } + }.awaitAll().flattenTo(ArraySet(360)) + } + + private suspend fun getTags(page: Int): Set { + val url = "https://$domain/tags/popular/pag/$page/" + val root = webClient.httpGet(url).parseHtml() + return root.parseTags() + } + + private fun Element.parseTags() = select(".list_tags a.tag_btn").mapToSet { + val key = it.attr("href").removeSuffix('/').substringAfterLast('/') + MangaTag( + key = key, + title = it.selectFirstOrThrow("h3").text(), + source = source, + ) + } + + + override suspend fun getDetails(manga: Manga): Manga { + val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() + val urlChapters = manga.url.replace("/gallery/", "/g/") + "1/" + return manga.copy( + altTitle = null, + tags = doc.select("ul.tags a.tag_btn ").mapNotNullToSet { + val key = it.attr("href").removeSuffix('/').substringAfterLast('/') + MangaTag( + key = key, + title = it.html().substringBefore(" { + val doc = webClient.httpGet(seed.url.toAbsoluteUrl(domain)).parseHtml() + val root = doc.body().selectFirstOrThrow(".related_galleries") + return root.select("div.thumb").mapNotNull { div -> + val a = div.selectFirst(".inner_thumb a") ?: return@mapNotNull null + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = href.toAbsoluteUrl(a.host ?: domain), + altTitle = null, + title = div.selectFirstOrThrow("h2.g_title").text(), + author = null, + coverUrl = div.selectFirst("img")?.src().orEmpty(), + tags = emptySet(), + rating = RATING_UNKNOWN, + state = null, + isNsfw = isNsfwSource, + source = source, + ) + } + } + + override suspend fun getPages(chapter: MangaChapter): List { + val doc = webClient.httpGet(chapter.url.toAbsoluteUrl(domain)).parseHtml() + val totalPages = doc.selectFirstOrThrow(".total_pages").text().toInt() + val rawUrl = chapter.url.replace("/1/", "/") + return (1..totalPages).map { + val url = "$rawUrl$it/" + MangaPage( + id = generateUid(url), + url = url, + preview = null, + source = source, + ) + } + } + + override suspend fun getPageUrl(page: MangaPage): String { + val doc = webClient.httpGet(page.url.toAbsoluteUrl(domain)).parseHtml() + val root = doc.body() + return root.requireElementById("gimg").attrAsAbsoluteUrl("data-src") + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/ImHentai.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/ImHentai.kt new file mode 100644 index 000000000..4ecc1c1e3 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/ImHentai.kt @@ -0,0 +1,180 @@ +package org.koitharu.kotatsu.parsers.site.all + +import androidx.collection.ArraySet +import kotlinx.coroutines.async +import kotlinx.coroutines.awaitAll +import kotlinx.coroutines.coroutineScope +import org.jsoup.nodes.Element +import org.koitharu.kotatsu.parsers.MangaLoaderContext +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.util.* +import java.util.* + +@MangaSourceParser("IMHENTAI", "ImHentai", type = ContentType.HENTAI) +internal class ImHentai(context: MangaLoaderContext) : + PagedMangaParser(context, MangaSource.IMHENTAI, pageSize = 20) { + + override val sortOrders: Set = + EnumSet.of(SortOrder.UPDATED, SortOrder.POPULARITY, SortOrder.RATING) + + override val configKeyDomain = ConfigKey.Domain("imhentai.xxx") + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + val tag = tags.oneOrThrowIfMany() + val url = buildString { + append("https://") + append(domain) + + if (!query.isNullOrEmpty()) { + append("/search/?key=") + append(query.urlEncoded()) + append("&page=") + append(page) + } else if (!tags.isNullOrEmpty()) { + append("/tag/") + append(tag?.key.orEmpty()) + append("/") + when (sortOrder) { + SortOrder.UPDATED -> append("") + SortOrder.POPULARITY -> append("popular/") + else -> append("") + } + append("?page=") + append(page) + } else { + append("/search/?page=") + append(page) + when (sortOrder) { + SortOrder.UPDATED -> append("<=1&pp=0") + SortOrder.POPULARITY -> append("<=0&pp=1") + SortOrder.RATING -> append("<=0&pp=0") + else -> append("<=1&pp=0") + } + } + } + val doc = webClient.httpGet(url).parseHtml() + return doc.select("div.galleries div.thumb").map { div -> + val a = div.selectFirstOrThrow(".inner_thumb a") + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = href.toAbsoluteUrl(domain), + coverUrl = a.selectFirst("img")?.src().orEmpty(), + title = div.selectFirst(".caption")?.text().orEmpty(), + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + author = null, + state = null, + source = source, + isNsfw = isNsfwSource, + ) + } + } + + //Tags are deliberately reduced because there are too many and this slows down the application. + //only the most popular ones are taken. + override suspend fun getTags(): Set { + return coroutineScope { + (1..3).map { page -> + async { getTags(page) } + } + }.awaitAll().flattenTo(ArraySet(360)) + } + + private suspend fun getTags(page: Int): Set { + val url = "https://$domain/tags/popular/?page=$page" + val root = webClient.httpGet(url).parseHtml() + return root.parseTags() + } + + private fun Element.parseTags() = select("div.stags a.tag_btn").mapToSet { + val href = it.attr("href").substringAfterLast("tag/").substringBeforeLast('/') + MangaTag( + key = href, + title = it.selectFirstOrThrow("h3.list_tag").text(), + source = source, + ) + } + + override suspend fun getDetails(manga: Manga): Manga = coroutineScope { + val fullUrl = manga.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + manga.copy( + tags = doc.body().select("li:contains(Tags) a.tag").mapNotNullToSet { + val href = it.attr("href").substringAfterLast("tag/").substringBeforeLast('/') + val name = it.html().substringBeforeLast(" { + val doc = webClient.httpGet(seed.url.toAbsoluteUrl(domain)).parseHtml() + val root = doc.body().selectFirstOrThrow("div.related") + return root.select("div.thumb").mapNotNull { div -> + val a = div.selectFirstOrThrow(".inner_thumb a") + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = href.toAbsoluteUrl(domain), + coverUrl = a.selectFirst("img")?.src().orEmpty(), + title = div.selectFirst(".caption")?.text().orEmpty(), + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + author = null, + state = null, + source = source, + isNsfw = false, + ) + } + } + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + val totalPages = doc.selectFirstOrThrow(".pages").text().replace("Pages: ", "").toInt() + 1 + val domainImg = doc.requireElementById("append_thumbs").selectFirstOrThrow("img").src()?.replace("1t.jpg", "") + val pages = ArrayList(totalPages) + for (i in 1 until totalPages) { + val url = "$domainImg$i.jpg" + pages.add( + MangaPage( + id = generateUid(url), + url = url, + preview = null, + source = source, + ), + ) + } + return pages + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/LineWebtoonsParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/LineWebtoonsParser.kt similarity index 99% rename from src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/LineWebtoonsParser.kt rename to src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/LineWebtoonsParser.kt index f60a07dee..03122d118 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/LineWebtoonsParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/LineWebtoonsParser.kt @@ -1,4 +1,4 @@ -package org.koitharu.kotatsu.parsers.site.en +package org.koitharu.kotatsu.parsers.site.all import kotlinx.coroutines.async import kotlinx.coroutines.coroutineScope diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/animebootstrap/AnimeBootstrapParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/animebootstrap/AnimeBootstrapParser.kt index 0b1c33fab..1df0d2c6c 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/animebootstrap/AnimeBootstrapParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/animebootstrap/AnimeBootstrapParser.kt @@ -114,7 +114,7 @@ internal abstract class AnimeBootstrapParser( val fullUrl = manga.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() - val chaptersDeferred = async { getChapters(manga, doc) } + val chaptersDeferred = async { getChapters(doc) } val desc = doc.selectFirstOrThrow(selectDesc).html() @@ -141,7 +141,7 @@ internal abstract class AnimeBootstrapParser( protected open val selectChapter = "div.anime__details__episodes a" - protected open suspend fun getChapters(manga: Manga, doc: Document): List { + protected open suspend fun getChapters(doc: Document): List { return doc.body().select(selectChapter).mapChapters(reversed = true) { i, a -> val href = a.attr("href") MangaChapter( diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/animebootstrap/fr/PapScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/animebootstrap/fr/PapScan.kt index 175fef3af..90ea3064b 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/animebootstrap/fr/PapScan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/animebootstrap/fr/PapScan.kt @@ -102,7 +102,7 @@ internal class PapScan(context: MangaLoaderContext) : val fullUrl = manga.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() - val chaptersDeferred = async { getChapters(manga, doc) } + val chaptersDeferred = async { getChapters(doc) } val desc = doc.selectFirstOrThrow(selectDesc).html() @@ -126,7 +126,7 @@ internal class PapScan(context: MangaLoaderContext) : ) } - override suspend fun getChapters(manga: Manga, doc: Document): List { + override suspend fun getChapters(doc: Document): List { val dateFormat = SimpleDateFormat(datePattern, sourceLocale) return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val href = li.selectFirstOrThrow("a").attr("href") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ar/FlixScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ar/FlixScans.kt new file mode 100644 index 000000000..03bb8d38e --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ar/FlixScans.kt @@ -0,0 +1,167 @@ +package org.koitharu.kotatsu.parsers.site.ar + +import kotlinx.coroutines.async +import kotlinx.coroutines.coroutineScope +import org.json.JSONArray +import org.json.JSONObject +import org.koitharu.kotatsu.parsers.MangaLoaderContext +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.util.* +import org.koitharu.kotatsu.parsers.util.json.mapJSON +import org.koitharu.kotatsu.parsers.util.json.mapJSONIndexed +import java.text.SimpleDateFormat +import java.util.* + +@MangaSourceParser("FLIXSCANS", "Flix Scans", "ar") +internal class FlixScans(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.FLIXSCANS, 18) { + + override val sortOrders: Set = EnumSet.of(SortOrder.UPDATED) + override val configKeyDomain = ConfigKey.Domain("flixscans.com") + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + val json = if (!query.isNullOrEmpty()) { + if (page > 1) { + return emptyList() + } + val url = "https://api.$domain/api/v1/search/serie" + val body = JSONObject() + body.put("title", query.urlEncoded()) + webClient.httpPost(url, body).parseJson().getJSONArray("data") + } else if (!tags.isNullOrEmpty()) { + if (page > 1) { + return emptyList() + } + val tagQuery = tags.joinToString(separator = ",") { it.key } + val url = "https://api.$domain/api/v1/search/advance?=&genres=$tagQuery&serie_type=webtoon" + webClient.httpGet(url).parseJson().getJSONArray("data") + } else { + val url = "https://api.$domain/api/v1/webtoon/homepage/latest/home?page=$page" + webClient.httpGet(url).parseJson().getJSONArray("data") + } + return json.mapJSON { j -> + val href = "https://$domain/series/${j.getString("prefix")}-${j.getString("id")}-${j.getString("slug")}" + val cover = "https://api.$domain/storage/" + j.getString("thumbnail") + Manga( + id = generateUid(href), + title = j.getString("title"), + altTitle = null, + url = href, + publicUrl = href.toAbsoluteUrl(domain), + rating = RATING_UNKNOWN, + isNsfw = false, + coverUrl = cover, + tags = emptySet(), + state = when (j.getString("status")) { + "ongoing" -> MangaState.ONGOING + "completed" -> MangaState.FINISHED + else -> null + }, + author = null, + source = source, + ) + } + } + + override suspend fun getTags(): Set { + val doc = webClient.httpGet("https://$domain/search/advance").parseHtml() + val json = JSONArray(doc.requireElementById("__NUXT_DATA__").data()) + val tagsList = json.getJSONArray(3).toString().replace("[", "").replace("]", "").split(",") + return tagsList.mapNotNullToSet { idTag -> + val id = idTag.toInt() + val idKey = json.getJSONObject(id).getInt("id") + val key = json.get(idKey).toString() + val idName = json.getJSONObject(id).getInt("name") + val name = json.get(idName).toString() + MangaTag( + key = key, + title = name, + source = source, + ) + } + } + + override suspend fun getDetails(manga: Manga): Manga = coroutineScope { + val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() + val chaptersDeferred = async { loadChapters(manga.url) } + val json = JSONArray(doc.requireElementById("__NUXT_DATA__").data()) + val descId = json.getJSONObject(6).getInt("story") + val desc = json.getString(descId) + val tagsId = json.getJSONObject(6).getInt("genres") + val tagsList = json.getJSONArray(tagsId).toString().replace("[", "").replace("]", "").split(",") + val ratingId = json.getJSONObject(6).getInt("rating") + val rating = json.getString(ratingId) + val nsfwId = json.getJSONObject(6).getInt("nsfw") + val nsfw = json.getBoolean(nsfwId) + manga.copy( + description = desc, + tags = tagsList.mapToSet { idTag -> + val id = idTag.toInt() + val idKey = json.getJSONObject(id).getInt("id") + val key = json.get(idKey).toString() + val idName = json.getJSONObject(id).getInt("name") + val name = json.get(idName).toString() + MangaTag( + key = key, + title = name, + source = source, + ) + }, + rating = rating?.toFloatOrNull()?.div(5f) ?: RATING_UNKNOWN, + isNsfw = nsfw, + chapters = chaptersDeferred.await(), + ) + } + + private val dateFormat = SimpleDateFormat("yyyy-MM-dd", sourceLocale) + + private suspend fun loadChapters(baseUrl: String): List { + val key = baseUrl.substringAfter("-").substringBefore("-") + val seriesKey = baseUrl.substringAfterLast("/").substringBefore("-") + val json = JSONArray(webClient.httpGet("https://api.$domain/api/v1/webtoon/chapters/$key-desc").parseRaw()) + return json.mapJSONIndexed { i, j -> + val url = "https://$domain/read/webtoon/$seriesKey-${j.getString("id")}-${j.getString("slug")}" + val date = j.getString("createdAt").substringBeforeLast("T") + MangaChapter( + id = generateUid(url), + url = url, + name = j.getString("slug").replace('-', ' '), + number = i + 1, + branch = null, + uploadDate = dateFormat.tryParse(date), + scanlator = null, + source = source, + ) + } + } + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + val json = JSONArray(doc.requireElementById("__NUXT_DATA__").data()) + val chapterData = json.getJSONObject(6).getInt("chapterData") + val pageLocate = json.getJSONObject(chapterData).getInt("webtoon") + val jsonPages = json.getJSONArray(pageLocate) + val pages = ArrayList(jsonPages.length()) + for (i in 0 until jsonPages.length()) { + val id = jsonPages.getInt(i) + val url = "https://api.$domain/storage/" + json.getString(id) + pages.add( + MangaPage( + id = generateUid(url), + url = url, + preview = null, + source = source, + ) + ) + } + return pages + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ar/MangaStorm.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ar/MangaStorm.kt new file mode 100644 index 000000000..754ad8ff1 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ar/MangaStorm.kt @@ -0,0 +1,120 @@ +package org.koitharu.kotatsu.parsers.site.ar + +import okhttp3.Headers +import org.koitharu.kotatsu.parsers.MangaLoaderContext +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 java.util.* + +@MangaSourceParser("MANGASTORM", "Manga Storm", "ar") +internal class MangaStorm(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.MANGASTORM, 30) { + + override val sortOrders: Set = EnumSet.of(SortOrder.POPULARITY) + override val configKeyDomain = ConfigKey.Domain("mangastorm.org") + + override val headers: Headers = Headers.Builder() + .add("User-Agent", UserAgents.CHROME_DESKTOP) + .build() + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + val tag = tags.oneOrThrowIfMany() + val url = + if (!tags.isNullOrEmpty()) { + buildString { + append("https://") + append(domain) + append("/categories/") + append(tag?.key.orEmpty()) + append("?page=") + append(page) + } + } else { + buildString { + append("https://") + append(domain) + append("/mangas?page=") + append(page) + if (!query.isNullOrEmpty()) { + append("&query=") + append(query.urlEncoded()) + } + } + } + val doc = webClient.httpGet(url).parseHtml() + return doc.select("div.row div.col").map { div -> + val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + title = div.select(".manga-ct-title").text(), + altTitle = null, + url = href, + publicUrl = href.toAbsoluteUrl(domain), + rating = RATING_UNKNOWN, + isNsfw = false, + coverUrl = div.selectFirstOrThrow("img").src().orEmpty(), + tags = emptySet(), + state = null, + author = null, + source = source, + ) + } + } + + override suspend fun getTags(): Set = emptySet() + + override suspend fun getDetails(manga: Manga): Manga { + val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() + + val root = doc.selectFirstOrThrow(".card-body .col-lg-9") + + return manga.copy( + altTitle = null, + state = null, + tags = root.select(".flex-wrap a").mapNotNullToSet { a -> + MangaTag( + key = a.attr("href").substringAfterLast('/'), + title = a.text(), + source = source, + ) + }, + author = null, + description = root.selectFirstOrThrow(".card-text").text(), + chapters = doc.select(".card-body a.btn-fixed-width").mapChapters(reversed = true) { i, a -> + val url = a.attrAsRelativeUrl("href") + MangaChapter( + id = generateUid(url), + name = a.text(), + number = i + 1, + url = url, + scanlator = null, + uploadDate = 0, + branch = null, + source = source, + ) + }, + ) + } + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml().requireElementById("content") + return doc.select("div.text-center .img-fluid").map { img -> + val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found") + MangaPage( + id = generateUid(url), + url = url, + preview = null, + source = source, + ) + } + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ar/TeamXNovel.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ar/TeamXNovel.kt index 293627794..7a7cee353 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ar/TeamXNovel.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ar/TeamXNovel.kt @@ -17,7 +17,7 @@ import java.util.* internal class TeamXNovel(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.TEAMXNOVEL, 10) { override val sortOrders: Set = EnumSet.of(SortOrder.UPDATED, SortOrder.POPULARITY) - override val configKeyDomain = ConfigKey.Domain("team1x12.com") + override val configKeyDomain = ConfigKey.Domain("team11x11.com") override suspend fun getListPage( page: Int, @@ -26,9 +26,9 @@ internal class TeamXNovel(context: MangaLoaderContext) : PagedMangaParser(contex sortOrder: SortOrder, ): List { val tag = tags.oneOrThrowIfMany() - val url = buildString { - append("https://$domain") + append("https://") + append(domain) if (!tags.isNullOrEmpty()) { append("/series?genre=") append(tag?.key.orEmpty()) @@ -57,7 +57,6 @@ internal class TeamXNovel(context: MangaLoaderContext) : PagedMangaParser(contex } val doc = webClient.httpGet(url).parseHtml() - return doc.select("div.listupd .bs .bsx").ifEmpty { doc.select("div.post-body .box") }.map { div -> @@ -97,7 +96,6 @@ internal class TeamXNovel(context: MangaLoaderContext) : PagedMangaParser(contex override suspend fun getDetails(manga: Manga): Manga { val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() val mangaUrl = manga.url.toAbsoluteUrl(domain) - val maxPageChapterSelect = doc.select(".pagination .page-item a") var maxPageChapter = 1 if (!maxPageChapterSelect.isNullOrEmpty()) { @@ -108,7 +106,6 @@ internal class TeamXNovel(context: MangaLoaderContext) : PagedMangaParser(contex } } } - return manga.copy( altTitle = null, state = when (doc.selectFirstOrThrow(".full-list-info:contains(الحالة:) a").text()) { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/CloneMangaParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/CloneMangaParser.kt index 5e5327e26..de747b609 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/CloneMangaParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/CloneMangaParser.kt @@ -9,7 +9,7 @@ import org.koitharu.kotatsu.parsers.model.* import org.koitharu.kotatsu.parsers.util.* import java.util.* -@MangaSourceParser("CLONEMANGA", "CloneManga", "en") +@MangaSourceParser("CLONEMANGA", "Clone Manga", "en") internal class CloneMangaParser(context: MangaLoaderContext) : MangaParser(context, MangaSource.CLONEMANGA) { override val sortOrders: Set = Collections.singleton( diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/ComicExtra.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/ComicExtra.kt index 82d0a4a58..731545bb2 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/ComicExtra.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/ComicExtra.kt @@ -11,7 +11,7 @@ import org.koitharu.kotatsu.parsers.util.* import java.text.SimpleDateFormat import java.util.* -@MangaSourceParser("COMICEXTRA", "ComicExtra", "en") +@MangaSourceParser("COMICEXTRA", "Comic Extra", "en") internal class ComicExtra(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.COMICEXTRA, 25) { override val sortOrders: Set = EnumSet.of(SortOrder.POPULARITY, SortOrder.UPDATED, SortOrder.NEWEST) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Fakku.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Fakku.kt new file mode 100644 index 000000000..cfc72d1b3 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Fakku.kt @@ -0,0 +1,146 @@ +package org.koitharu.kotatsu.parsers.site.en + +import kotlinx.coroutines.async +import kotlinx.coroutines.coroutineScope +import org.koitharu.kotatsu.parsers.MangaLoaderContext +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.util.* +import org.koitharu.kotatsu.parsers.util.json.mapJSONToSet +import java.util.* + +@MangaSourceParser("FAKKU", "Fakku", "en", ContentType.HENTAI) +internal class Fakku(context: MangaLoaderContext) : + PagedMangaParser(context, MangaSource.FAKKU, pageSize = 25) { + + override val sortOrders: Set = + EnumSet.of(SortOrder.ALPHABETICAL, SortOrder.NEWEST, SortOrder.UPDATED) + + override val configKeyDomain = ConfigKey.Domain("fakku.cc") + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + val tag = tags.oneOrThrowIfMany() + val url = buildString { + append("https://") + append(domain) + when { + !query.isNullOrEmpty() -> { + append("/search?q=") + append(query.urlEncoded()) + append("&") + } + + !tags.isNullOrEmpty() -> { + append("/tags/") + append(tag?.key.orEmpty()) + append("?") + } + + else -> { + append("?") + } + } + append("page=") + append(page) + append("&sort=") + when (sortOrder) { + SortOrder.ALPHABETICAL -> append("title") + SortOrder.NEWEST -> append("created_at") + SortOrder.UPDATED -> append("published_at") + else -> append("published_at") + } + } + val doc = webClient.httpGet(url).parseHtml() + return doc.select("div.entries .entry a").map { a -> + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = href.toAbsoluteUrl(domain), + coverUrl = a.selectFirst("img")?.src().orEmpty(), + title = a.selectFirst(".title")?.text().orEmpty(), + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + author = null, + state = null, + source = source, + isNsfw = isNsfwSource, + ) + } + } + + override suspend fun getTags(): Set { + val root = webClient.httpGet("https://$domain/tags").parseHtml() + return root.select("div.entries .entry a").mapToSet { + MangaTag( + key = it.attr("href").substringAfterLast("/"), + title = it.selectFirstOrThrow(".name").text(), + source = source, + ) + } + } + + override suspend fun getDetails(manga: Manga): Manga = coroutineScope { + val fullUrl = manga.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + val genreDeferred = async { + webClient.httpGet(manga.url.toAbsoluteUrl(domain) + ".json").parseJson() + } + val genre = genreDeferred.await() + manga.copy( + author = doc.selectFirst("tr.artists a")?.text(), + tags = if (genre.toString().contains("tags")) { + genre.getJSONArray("tags").mapJSONToSet { + MangaTag( + key = it.getString("slug"), + title = it.getString("name"), + source = source, + ) + } + } else { + emptySet() + }, + chapters = listOf( + MangaChapter( + id = manga.id, + name = manga.title, + number = 1, + url = manga.url + "/1", + scanlator = null, + uploadDate = 0, + branch = null, + source = source, + ), + ), + ) + } + + override suspend fun getPages(chapter: MangaChapter): List { + val doc = webClient.httpGet(chapter.url.toAbsoluteUrl(domain)).parseHtml() + val totalPages = doc.selectFirstOrThrow(".total").text().toInt() + val rawUrl = chapter.url.substringBeforeLast("/") + return (1..totalPages).map { + val url = "$rawUrl/$it" + MangaPage( + id = generateUid(url), + url = url, + preview = null, + source = source, + ) + } + } + + override suspend fun getPageUrl(page: MangaPage): String { + val doc = webClient.httpGet(page.url.toAbsoluteUrl(domain)).parseHtml() + val root = doc.body() + return root.selectFirstOrThrow(".page img").attrAsAbsoluteUrl("src") + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/LikeManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/LikeManga.kt index 8c349aeff..8af451c47 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/LikeManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/LikeManga.kt @@ -14,7 +14,7 @@ import java.text.DateFormat import java.text.SimpleDateFormat import java.util.* -@MangaSourceParser("LIKEMANGA", "LikeManga", "en") +@MangaSourceParser("LIKEMANGA", "Like Manga", "en") internal class LikeManga(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.LIKEMANGA, 36) { override val sortOrders: Set = EnumSet.of(SortOrder.UPDATED, SortOrder.POPULARITY, SortOrder.NEWEST) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Mangaowl.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Mangaowl.kt index 7df8fd722..af4167934 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Mangaowl.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Mangaowl.kt @@ -14,7 +14,7 @@ import org.koitharu.kotatsu.parsers.util.json.mapJSON import java.text.SimpleDateFormat import java.util.* -@MangaSourceParser("MANGAOWL", "Mangaowl", "en") +@MangaSourceParser("MANGAOWL", "Manga Owl .To", "en") internal class Mangaowl(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.MANGAOWL, pageSize = 24) { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Manhwa18Parser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Manhwa18Parser.kt index 35547adda..b73ace203 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Manhwa18Parser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Manhwa18Parser.kt @@ -9,7 +9,7 @@ import org.koitharu.kotatsu.parsers.model.* import org.koitharu.kotatsu.parsers.util.* import java.util.* -@MangaSourceParser("MANHWA18", "Manhwa18", "en", type = ContentType.HENTAI) +@MangaSourceParser("MANHWA18", "Manhwa 18", "en", type = ContentType.HENTAI) class Manhwa18Parser(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.MANHWA18, pageSize = 18, searchPageSize = 18) { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Pururin.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Pururin.kt new file mode 100644 index 000000000..1e9e71170 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Pururin.kt @@ -0,0 +1,168 @@ +package org.koitharu.kotatsu.parsers.site.en + +import androidx.collection.ArraySet +import kotlinx.coroutines.async +import kotlinx.coroutines.awaitAll +import kotlinx.coroutines.coroutineScope +import org.jsoup.nodes.Element +import org.koitharu.kotatsu.parsers.MangaLoaderContext +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.util.* +import java.util.* + +@MangaSourceParser("PURURIN", "Pururin", "en", ContentType.HENTAI) +internal class Pururin(context: MangaLoaderContext) : + PagedMangaParser(context, MangaSource.PURURIN, pageSize = 20) { + + override val sortOrders: Set = + EnumSet.of(SortOrder.UPDATED, SortOrder.POPULARITY, SortOrder.RATING, SortOrder.ALPHABETICAL) + + override val configKeyDomain = ConfigKey.Domain("pururin.to") + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + val tag = tags.oneOrThrowIfMany() + val url = buildString { + append("https://") + append(domain) + if (!query.isNullOrEmpty()) { + append("/search?q=") + append(query.urlEncoded()) + append("&page=") + append(page) + } else { + append("/browse") + if (!tags.isNullOrEmpty()) { + append("/tags/content/") + append(tag?.key.orEmpty()) + append("/") + } + append("?page=") + append(page) + append("&sort=") + when (sortOrder) { + SortOrder.UPDATED -> append("") + SortOrder.POPULARITY -> append("most-viewed") + SortOrder.RATING -> append("highest-rated") + SortOrder.ALPHABETICAL -> append("title") + else -> append("") + } + } + } + val doc = webClient.httpGet(url).parseHtml() + return doc.select(".row-gallery a.card-gallery").map { a -> + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = href.toAbsoluteUrl(domain), + coverUrl = a.selectFirst("img.card-img-top")?.src().orEmpty(), + title = a.selectFirst(".title")?.text().orEmpty(), + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + author = null, + state = null, + source = source, + isNsfw = isNsfwSource, + ) + } + } + + override suspend fun getTags(): Set { + return coroutineScope { + (1..4).map { page -> + async { getTags(page) } + } + }.awaitAll().flattenTo(ArraySet(360)) + } + + private suspend fun getTags(page: Int): Set { + val url = "https://$domain/tags/content?order=uses&page=$page" + val root = webClient.httpGet(url).parseHtml() + return root.parseTags() + } + + private fun Element.parseTags() = select("table tr td a").mapToSet { + val href = it.attr("href").substringAfterLast("content/").substringBeforeLast('/') + MangaTag( + key = href, + title = it.text(), + source = source, + ) + } + + override suspend fun getDetails(manga: Manga): Manga = coroutineScope { + val fullUrl = manga.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + manga.copy( + description = doc.selectFirst("p.mb-2")?.text().orEmpty(), + rating = doc.selectFirst("td span.rating")?.attr("content")?.toFloatOrNull()?.div(5f) ?: RATING_UNKNOWN, + tags = doc.body().select("tr:contains(Contents) ul.list-inline a").mapNotNullToSet { + val href = it.attr("href").substringAfterLast("content/").substringBeforeLast('/') + MangaTag( + key = href, + title = it.text(), + source = source, + ) + }, + author = doc.selectFirst("a[itemprop=author]")?.text(), + chapters = listOf( + MangaChapter( + id = manga.id, + name = manga.title, + number = 1, + url = manga.url, + scanlator = null, + uploadDate = 0, + branch = null, + source = source, + ), + ), + ) + } + + override suspend fun getRelatedManga(seed: Manga): List { + val doc = webClient.httpGet(seed.url.toAbsoluteUrl(domain)).parseHtml() + val root = doc.body().selectFirstOrThrow(".row-gallery-small") + return root.select("a.card-gallery").mapNotNull { a -> + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = href.toAbsoluteUrl(domain), + coverUrl = a.selectFirst("img.card-img-top")?.src().orEmpty(), + title = a.selectFirst(".title")?.text().orEmpty(), + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + author = null, + state = null, + source = source, + isNsfw = false, + ) + } + } + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + return doc.select(".gallery-preview img").map { url -> + val img = url.src()?.toRelativeUrl(domain) ?: url.parseFailed("Image src not found") + val urlImage = img.replace("t.", ".") + MangaPage( + id = generateUid(urlImage), + url = urlImage, + preview = null, + source = source, + ) + } + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/es/TuMangaOnlineParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/es/TuMangaOnlineParser.kt index 24e2c9760..ba4329b0e 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/es/TuMangaOnlineParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/es/TuMangaOnlineParser.kt @@ -99,12 +99,12 @@ class TuMangaOnlineParser(context: MangaLoaderContext) : PagedMangaParser( state = parseStatus(contents.select("span.book-status").text().orEmpty()), author = contents.selectFirst("h5.card-title")?.attr("title")?.substringAfter(", "), chapters = if (doc.select("div.chapters").isEmpty()) { - doc.select(oneShotChapterListSelector()).mapChapters(reversed = true) { _, item -> + doc.select(oneShotChapterListSelector).mapChapters(reversed = true) { _, item -> oneShotChapterFromElement(item) } } else { val chapters = ChaptersListBuilder(10) - doc.select(regularChapterListSelector()).reversed().forEachIndexed { i, item -> + doc.select(regularChapterListSelector).reversed().forEachIndexed { i, item -> val chaptername = item.select("div.col-10.text-truncate").text().replace(" ", " ").trim() val scanelement = item.select("ul.chapter-list > li") scanelement.forEach { chapters.add(regularChapterFromElement(it, chaptername, i)) } @@ -114,7 +114,7 @@ class TuMangaOnlineParser(context: MangaLoaderContext) : PagedMangaParser( ) } - private fun oneShotChapterListSelector() = "div.chapter-list-element > ul.list-group li.list-group-item" + private val oneShotChapterListSelector = "div.chapter-list-element > ul.list-group li.list-group-item" private fun oneShotChapterFromElement(element: Element): MangaChapter { val href = element.selectFirstOrThrow("div.row > .text-right > a").attrAsRelativeUrl("href") @@ -130,7 +130,7 @@ class TuMangaOnlineParser(context: MangaLoaderContext) : PagedMangaParser( ) } - private fun regularChapterListSelector() = "div.chapters > ul.list-group li.p-0.list-group-item" + private val regularChapterListSelector = "div.chapters > ul.list-group li.p-0.list-group-item" private fun regularChapterFromElement(element: Element, chName: String, number: Int): MangaChapter { val href = element.selectFirstOrThrow("div.row > .text-right > a").attrAsRelativeUrl("href") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/FmreaderParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/FmreaderParser.kt index 457e834d4..a533f25ea 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/FmreaderParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/FmreaderParser.kt @@ -27,7 +27,7 @@ internal abstract class FmreaderParser( SortOrder.ALPHABETICAL, ) - protected open val listeurl = "/manga-list.html" + protected open val listUrl = "/manga-list.html" protected open val datePattern = "MMMM d, yyyy" protected open val tagPrefix = "manga-list-genre-" @@ -66,7 +66,7 @@ internal abstract class FmreaderParser( val url = buildString { append("https://") append(domain) - append(listeurl) + append(listUrl) append("?page=") append(page.toString()) when { @@ -114,7 +114,7 @@ internal abstract class FmreaderParser( protected open val selectBodyTag = "ul.filter-type li a" override suspend fun getTags(): Set { - val doc = webClient.httpGet("https://$domain/$listeurl").parseHtml() + val doc = webClient.httpGet("https://$domain/$listUrl").parseHtml() return doc.select(selectBodyTag).mapNotNullToSet { a -> val href = a.attr("href").substringAfter(tagPrefix).substringBeforeLast(".html") MangaTag( @@ -134,7 +134,7 @@ internal abstract class FmreaderParser( override suspend fun getDetails(manga: Manga): Manga = coroutineScope { val fullUrl = manga.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() - val chaptersDeferred = async { getChapters(manga, doc) } + val chaptersDeferred = async { getChapters(doc) } val desc = doc.selectFirstOrThrow(selectDesc).html() val stateDiv = doc.selectFirst(selectState) val state = stateDiv?.let { @@ -145,7 +145,6 @@ internal abstract class FmreaderParser( else -> null } } - val alt = doc.body().selectFirst(selectAlt)?.text()?.replace("Other names", "") val auth = doc.body().selectFirst(selectAut)?.text() manga.copy( @@ -168,7 +167,7 @@ internal abstract class FmreaderParser( protected open val selectDate = "div.chapter-time" protected open val selectChapter = "ul.list-chapters a" - protected open suspend fun getChapters(manga: Manga, doc: Document): List { + protected open suspend fun getChapters(doc: Document): List { val dateFormat = SimpleDateFormat(datePattern, sourceLocale) return doc.body().select(selectChapter).mapChapters(reversed = true) { i, a -> val href = a.attrAsRelativeUrl("href") @@ -194,10 +193,8 @@ internal abstract class FmreaderParser( override suspend fun getPages(chapter: MangaChapter): List { val fullUrl = chapter.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() - return doc.select(selectPage).map { img -> val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found") - MangaPage( id = generateUid(url), url = url, diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/en/Manhwa18Com.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/en/Manhwa18Com.kt index eeb9c7d1f..cd4ddfe0b 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/en/Manhwa18Com.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/en/Manhwa18Com.kt @@ -10,11 +10,11 @@ import org.koitharu.kotatsu.parsers.site.fmreader.FmreaderParser import org.koitharu.kotatsu.parsers.util.* import java.text.SimpleDateFormat -@MangaSourceParser("MANHWA18COM", "Manhwa18 .Com", "en", ContentType.HENTAI) +@MangaSourceParser("MANHWA18COM", "Manhwa 18 .Com", "en", ContentType.HENTAI) internal class Manhwa18Com(context: MangaLoaderContext) : FmreaderParser(context, MangaSource.MANHWA18COM, "manhwa18.com") { - override val listeurl = "/tim-kiem" + override val listUrl = "/tim-kiem" override val selectState = "div.info-item:contains(Status) span.info-value " override val selectAlt = "div.info-item:contains(Other name) span.info-value " override val selectTag = "div.info-item:contains(Genre) span.info-value a" @@ -45,7 +45,7 @@ internal class Manhwa18Com(context: MangaLoaderContext) : else -> append("last_update") } } else { - append(listeurl) + append(listUrl) append("?page=") append(page.toString()) when { @@ -87,7 +87,7 @@ internal class Manhwa18Com(context: MangaLoaderContext) : } override suspend fun getTags(): Set { - val doc = webClient.httpGet("https://$domain/$listeurl").parseHtml() + val doc = webClient.httpGet("https://$domain/$listUrl").parseHtml() return doc.select(selectBodyTag).mapNotNullToSet { a -> val href = a.attr("href").substringAfterLast("/") MangaTag( @@ -101,7 +101,7 @@ internal class Manhwa18Com(context: MangaLoaderContext) : override suspend fun getDetails(manga: Manga): Manga = coroutineScope { val fullUrl = manga.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() - val chaptersDeferred = async { getChapters(manga, doc) } + val chaptersDeferred = async { getChapters(doc) } val desc = doc.selectFirstOrThrow(selectDesc).html() val stateDiv = doc.selectFirst(selectState) val state = stateDiv?.let { @@ -129,7 +129,7 @@ internal class Manhwa18Com(context: MangaLoaderContext) : ) } - override suspend fun getChapters(manga: Manga, doc: Document): List { + override suspend fun getChapters(doc: Document): List { val dateFormat = SimpleDateFormat(datePattern, sourceLocale) return doc.body().select(selectChapter).mapChapters(reversed = true) { i, a -> val href = a.attrAsRelativeUrl("href") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/es/OlimpoScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/es/OlimpoScans.kt index 78e171a7f..7cbaba4d4 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/es/OlimpoScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/es/OlimpoScans.kt @@ -25,7 +25,7 @@ internal class OlimpoScans(context: MangaLoaderContext) : val url = buildString { append("https://") append(domain) - append(listeurl) + append(listUrl) append("?page=") append(page.toString()) when { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/ja/Klz9.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/ja/Klz9.kt index 0f2a327d9..9d363040f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/ja/Klz9.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/ja/Klz9.kt @@ -37,7 +37,7 @@ internal class Klz9(context: MangaLoaderContext) : val url = buildString { append("https://") append(domain) - append("/$listeurl") + append("/$listUrl") append("?page=") append(page.toString()) when { @@ -81,12 +81,12 @@ internal class Klz9(context: MangaLoaderContext) : } } - override suspend fun getChapters(manga: Manga, doc: Document): List { + override suspend fun getChapters(doc: Document): List { val slug = doc.selectFirstOrThrow("div.h0rating").attr("slug") - val docload = + val docLoad = webClient.httpGet("https://$domain/app/manga/controllers/cont.listChapter.php?slug=$slug").parseHtml() val dateFormat = SimpleDateFormat(datePattern, sourceLocale) - return docload.body().select(selectChapter).mapChapters(reversed = true) { i, a -> + return docLoad.body().select(selectChapter).mapChapters(reversed = true) { i, a -> val href = "/" + a.selectFirstOrThrow("a.chapter").attrAsRelativeUrl("href") val dateText = a.selectFirst(selectDate)?.text() MangaChapter( @@ -109,8 +109,8 @@ internal class Klz9(context: MangaLoaderContext) : val fullUrl = chapter.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() val cid = doc.selectFirstOrThrow("#chapter").attr("value") - val docload = webClient.httpGet("https://$domain/app/manga/controllers/cont.listImg.php?cid=$cid").parseHtml() - return docload.select(selectPage).map { img -> + val docLoad = webClient.httpGet("https://$domain/app/manga/controllers/cont.listImg.php?cid=$cid").parseHtml() + return docLoad.select(selectPage).map { img -> val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found") MangaPage( diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/ja/WeLoveManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/ja/WeLoveManga.kt index 880723955..2fbc3bd29 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/ja/WeLoveManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fmreader/ja/WeLoveManga.kt @@ -3,7 +3,6 @@ package org.koitharu.kotatsu.parsers.site.fmreader.ja import org.jsoup.nodes.Document import org.koitharu.kotatsu.parsers.MangaLoaderContext import org.koitharu.kotatsu.parsers.MangaSourceParser -import org.koitharu.kotatsu.parsers.model.Manga import org.koitharu.kotatsu.parsers.model.MangaChapter import org.koitharu.kotatsu.parsers.model.MangaPage import org.koitharu.kotatsu.parsers.model.MangaSource @@ -11,16 +10,16 @@ import org.koitharu.kotatsu.parsers.site.fmreader.FmreaderParser import org.koitharu.kotatsu.parsers.util.* import java.text.SimpleDateFormat -@MangaSourceParser("WELOVEMANGA", "WeLoveManga", "ja") +@MangaSourceParser("WELOVEMANGA", "We Love Manga", "ja") internal class WeLoveManga(context: MangaLoaderContext) : FmreaderParser(context, MangaSource.WELOVEMANGA, "welovemanga.one") { - override suspend fun getChapters(manga: Manga, doc: Document): List { + override suspend fun getChapters(doc: Document): List { val mid = doc.selectFirstOrThrow("div.cmt input").attr("value") - val docload = + val docLoad = webClient.httpGet("https://$domain/app/manga/controllers/cont.Listchapter.php?mid=$mid").parseHtml() val dateFormat = SimpleDateFormat(datePattern, sourceLocale) - return docload.body().select(selectChapter).mapChapters(reversed = true) { i, a -> + return docLoad.body().select(selectChapter).mapChapters(reversed = true) { i, a -> val href = a.selectFirstOrThrow("a").attrAsRelativeUrl("href") val dateText = a.selectFirst(selectDate)?.text() MangaChapter( @@ -43,8 +42,8 @@ internal class WeLoveManga(context: MangaLoaderContext) : val fullUrl = chapter.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() val cid = doc.selectFirstOrThrow("#chapter").attr("value") - val docload = webClient.httpGet("https://$domain/app/manga/controllers/cont.listImg.php?cid=$cid").parseHtml() - return docload.select("img").map { img -> + val docLoad = webClient.httpGet("https://$domain/app/manga/controllers/cont.listImg.php?cid=$cid").parseHtml() + return docLoad.select("img").map { img -> val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found") MangaPage( diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/FoolSlideParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/FoolSlideParser.kt index ee9298d31..77b750e93 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/FoolSlideParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/FoolSlideParser.kt @@ -38,7 +38,6 @@ internal abstract class FoolSlideParser( tags: Set?, sortOrder: SortOrder, ): List { - val doc = if (!query.isNullOrEmpty()) { val url = buildString { append("https://$domain/$searchUrl") @@ -62,7 +61,6 @@ internal abstract class FoolSlideParser( } webClient.httpGet(url).parseHtml() } - return doc.select("div.list div.group").map { div -> val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href") Manga( @@ -90,26 +88,22 @@ internal abstract class FoolSlideParser( override suspend fun getDetails(manga: Manga): Manga = coroutineScope { val fullUrl = manga.url.toAbsoluteUrl(domain) val testAdultPage = webClient.httpGet(fullUrl).parseHtml() - val doc = if (testAdultPage.selectFirst("div.info form") != null) { webClient.httpPost(fullUrl, "adult=true").parseHtml() } else { testAdultPage } - val chapters = getChapters(manga, doc) - + val chapters = getChapters(doc) val desc = if (doc.selectFirstOrThrow(selectInfo).html().contains("")) { doc.selectFirstOrThrow(selectInfo).text().substringAfterLast(": ") } else { doc.selectFirstOrThrow(selectInfo).text() } - val author = if (doc.selectFirstOrThrow(selectInfo).html().contains("")) { doc.selectFirstOrThrow(selectInfo).text().substringAfter(": ").substringBefore("Art") } else { null } - manga.copy( coverUrl = doc.selectFirst(".thumbnail img")?.src() ?: manga.coverUrl, description = desc, @@ -124,7 +118,7 @@ internal abstract class FoolSlideParser( protected open val selectDate = ".meta_r" protected open val selectChapter = "div.list div.element" - protected open suspend fun getChapters(manga: Manga, doc: Document): List { + protected open suspend fun getChapters(doc: Document): List { val dateFormat = SimpleDateFormat(datePattern, sourceLocale) return doc.body().select(selectChapter).mapChapters(reversed = true) { i, div -> val a = div.selectFirstOrThrow(".title a") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/en/AssortedScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/en/AssortedScans.kt index 4cecfd20e..f90c64ed3 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/en/AssortedScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/en/AssortedScans.kt @@ -77,7 +77,7 @@ internal class AssortedScans(context: MangaLoaderContext) : } else { testAdultPage } - val chapters = getChapters(manga, doc) + val chapters = getChapters(doc) val desc = doc.getElementById("series-desc")?.selectFirst("div")?.html() val alt = doc.getElementById("series-aliases")?.selectFirst("div.alias")?.text() val author = doc.getElementById("series-authors")?.selectFirst("div.author")?.text() @@ -97,7 +97,7 @@ internal class AssortedScans(context: MangaLoaderContext) : ) } - override suspend fun getChapters(manga: Manga, doc: Document): List { + override suspend fun getChapters(doc: Document): List { return doc.body().select("div.chapter").mapChapters(reversed = true) { i, div -> val a = div.selectFirstOrThrow("a") val href = a.attrAsRelativeUrl("href") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/en/Deathtollscans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/en/Deathtollscans.kt index b48095340..9e4efb947 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/en/Deathtollscans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/en/Deathtollscans.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.foolslide.FoolSlideParser -@MangaSourceParser("DEATHTOLLSCANS", "DeathToll Scans", "en") +@MangaSourceParser("DEATHTOLLSCANS", "Death Toll Scans", "en") internal class Deathtollscans(context: MangaLoaderContext) : FoolSlideParser(context, MangaSource.DEATHTOLLSCANS, "reader.deathtollscans.net", 26) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/en/Seinagi.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/en/Seinagi.kt index 307773027..6bd2bcf8c 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/en/Seinagi.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/en/Seinagi.kt @@ -21,7 +21,7 @@ internal class Seinagi(context: MangaLoaderContext) : } else { testAdultPage } - val chapters = getChapters(manga, doc) + val chapters = getChapters(doc) val desc = if (doc.selectFirstOrThrow(selectInfo).html().contains("Description")) { doc.selectFirstOrThrow(selectInfo).text().substringAfter("Description: ").substringBefore("Readings") } else { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/es/Pzykosis666hFansub.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/es/Pzykosis666hFansub.kt index cc6fe49b8..90802ac73 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/es/Pzykosis666hFansub.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/es/Pzykosis666hFansub.kt @@ -19,7 +19,7 @@ internal class Pzykosis666hFansub(context: MangaLoaderContext) : } else { testAdultPage } - val chapters = getChapters(manga, doc) + val chapters = getChapters(doc) val desc = if (doc.selectFirstOrThrow(selectInfo).html().contains("Descripción")) { doc.selectFirstOrThrow(selectInfo).text().substringAfter("Descripción: ").substringBefore("Lecturas") } else { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/es/SeinagiAdulto.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/es/SeinagiAdulto.kt index 13af62831..261a6fbae 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/es/SeinagiAdulto.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/foolslide/es/SeinagiAdulto.kt @@ -25,7 +25,7 @@ internal class SeinagiAdulto(context: MangaLoaderContext) : } else { testAdultPage } - val chapters = getChapters(manga, doc) + val chapters = getChapters(doc) val desc = if (doc.selectFirstOrThrow(selectInfo).html().contains("Descripción")) { doc.selectFirstOrThrow(selectInfo).text().substringAfter("Descripción: ").substringBefore("Lecturas") } else { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/BentomangaParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/BentomangaParser.kt index 2ba817585..dab9a70b9 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/BentomangaParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/BentomangaParser.kt @@ -15,7 +15,7 @@ import org.koitharu.kotatsu.parsers.util.* import org.koitharu.kotatsu.parsers.util.json.getIntOrDefault import java.util.* -@MangaSourceParser("BENTOMANGA", "BentoManga", "fr") +@MangaSourceParser("BENTOMANGA", "Bento Manga", "fr") internal class BentomangaParser(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.BENTOMANGA, 10) { override val sortOrders: Set = EnumSet.of( diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/LugnicaScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/LugnicaScans.kt index 7ddd2cb41..2da188be3 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/LugnicaScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/LugnicaScans.kt @@ -9,6 +9,7 @@ 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.mapJSON +import java.lang.IllegalArgumentException import java.text.SimpleDateFormat import java.util.* @@ -48,20 +49,19 @@ internal class LugnicaScans(context: MangaLoaderContext) : PagedMangaParser(cont tags: Set?, sortOrder: SortOrder, ): List { - + if (!query.isNullOrEmpty()) { + throw IllegalArgumentException("Search is not supported by this source") + } if (sortOrder == SortOrder.ALPHABETICAL) { - if (page > 1) { return emptyList() } - val url = buildString { append("https://") append(domain) append("/api/get/catalog?page=0&filter=all") } val json = webClient.httpGet(url).parseJsonArray() - return json.mapJSON { j -> val urlManga = "https://$domain/api/get/card/${j.getString("slug")}" val img = "https://$domain/upload/min_cover/${j.getString("image")}" @@ -93,7 +93,6 @@ internal class LugnicaScans(context: MangaLoaderContext) : PagedMangaParser(cont append(page) } val json = webClient.httpGet(url).parseJsonArray() - return json.mapJSON { j -> val urlManga = "https://$domain/api/get/card/${j.getString("manga_slug")}" val img = "https://$domain/upload/min_cover/${j.getString("manga_image")}" @@ -119,10 +118,8 @@ internal class LugnicaScans(context: MangaLoaderContext) : PagedMangaParser(cont override suspend fun getDetails(manga: Manga): Manga { val json = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseJson() - val jsonManga = json.getJSONObject("manga") - val chapters = json.getJSONObject("chapters").toString().split("{\"id\":").drop(1) // Possible improvement here - + val chapters = json.getJSONObject("chapters").toString().split("{\"id\":").drop(1) val slug = manga.url.substringAfterLast("/") val dateFormat = SimpleDateFormat("dd-MM-yyyy", Locale.FRANCE) return manga.copy( @@ -140,8 +137,7 @@ internal class LugnicaScans(context: MangaLoaderContext) : PagedMangaParser(cont val url = "https://$domain/api/get/chapter/$slug/$id" val date = getDateString( it.substringAfter("\"date\":\"").substringBefore("\",").toLong(), - ) // Possible improvement here - + ) MangaChapter( id = generateUid(url), name = "Chapitre : $id", @@ -159,27 +155,25 @@ internal class LugnicaScans(context: MangaLoaderContext) : PagedMangaParser(cont private val simpleDateFormat = SimpleDateFormat("dd-MM-yyyy", Locale.FRANCE) private fun getDateString(time: Long): String = simpleDateFormat.format(time * 1000L) - override suspend fun getPages(chapter: MangaChapter): List { val fullUrl = chapter.url.toAbsoluteUrl(domain) val jsonPage = webClient.httpGet(fullUrl).parseJson() - - val idManga = jsonPage.getJSONObject("manga").getString("id") - val slugChapter = chapter.url.substringAfterLast("/") - - val pages = jsonPage.getJSONObject("chapter").getJSONArray("files").toString() - .replace("[", "").replace("]", "").replace("\"", "") - .split(",") // Possible improvement here - - return pages.map { img -> - val url = "https://$domain/upload/chapitre/$idManga/$slugChapter/$img" - MangaPage( - id = generateUid(url), - url = url, - preview = null, - source = source, + val idManga = jsonPage.getJSONObject("manga").getInt("id") + val slug = jsonPage.getJSONObject("chapter").getInt("chapter") + val jsonPages = jsonPage.getJSONObject("chapter").getJSONArray("files") + val pages = ArrayList(jsonPages.length()) + for (i in 0 until jsonPages.length()) { + val url = "https://$domain/upload/chapters/$idManga/$slug/${jsonPages.getString(i)}" + pages.add( + MangaPage( + id = generateUid(url), + url = url, + preview = null, + source = source, + ), ) } + return pages } override suspend fun getTags(): Set = emptySet() diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/ScansMangasMe.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/ScansMangasMe.kt index fff12eca1..4afeba990 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/ScansMangasMe.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/ScansMangasMe.kt @@ -167,7 +167,6 @@ internal class ScansMangasMe(context: MangaLoaderContext) : val pages = ArrayList(images.length()) for (i in 0 until images.length()) { - val pageTake = images.getJSONObject(i) pages.add( MangaPage( diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/heancmsalt/es/CerberuSeries.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/heancmsalt/es/CerberuSeries.kt index 2e06abcbf..2d46d626d 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/heancmsalt/es/CerberuSeries.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/heancmsalt/es/CerberuSeries.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.heancmsalt.HeanCmsAlt -@MangaSourceParser("LEGIONSCANS", "CerberuSeries", "es") +@MangaSourceParser("LEGIONSCANS", "Cerberus Series", "es") internal class CerberuSeries(context: MangaLoaderContext) : HeanCmsAlt(context, MangaSource.LEGIONSCANS, "cerberuseries.xyz") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/id/DoujinDesuParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/id/DoujinDesuParser.kt index bfa5c2d81..079259c4f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/id/DoujinDesuParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/id/DoujinDesuParser.kt @@ -9,7 +9,7 @@ import org.koitharu.kotatsu.parsers.util.* import java.text.SimpleDateFormat import java.util.* -@MangaSourceParser("DOUJINDESU", "DoujinDesu", "id") +@MangaSourceParser("DOUJINDESU", "Doujin Desu", "id") class DoujinDesuParser(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.DOUJINDESU, pageSize = 18) { override val configKeyDomain: ConfigKey.Domain diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ja/NicovideoSeigaParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ja/NicovideoSeigaParser.kt index dfec0e093..0937a0652 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ja/NicovideoSeigaParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ja/NicovideoSeigaParser.kt @@ -12,7 +12,7 @@ import java.util.* private const val STATUS_ONGOING = "連載" private const val STATUS_FINISHED = "完結" -@MangaSourceParser("NICOVIDEO_SEIGA", "NicoVideo Seiga", "ja") +@MangaSourceParser("NICOVIDEO_SEIGA", "Nico Video Seiga", "ja") class NicovideoSeigaParser(context: MangaLoaderContext) : MangaParser(context, MangaSource.NICOVIDEO_SEIGA), MangaParserAuthProvider { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/MadaraParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/MadaraParser.kt index 44ee2bdc7..353fc4e26 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/MadaraParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/MadaraParser.kt @@ -33,9 +33,8 @@ internal abstract class MadaraParser( protected open val tagPrefix = "manga-genre/" protected open val datePattern = "MMMM d, yyyy" - protected open val stylepage = "?style=list" - - protected open val postreq = false + protected open val stylePage = "?style=list" + protected open val postReq = false init { paginator.firstPage = 0 @@ -52,7 +51,6 @@ internal abstract class MadaraParser( parseFailed("Cannot find tableValue for node ${text()}") } - @JvmField protected val ongoing: Set = hashSetOf( "مستمرة", @@ -358,7 +356,7 @@ internal abstract class MadaraParser( return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirst("a") val href = a?.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") - val link = href + stylepage + val link = href + stylePage val dateText = li.selectFirst("a.c-new-tag")?.attr("title") ?: li.selectFirst(selectDate)?.text() val name = a.selectFirst("p")?.text() ?: a.ownText() MangaChapter( @@ -378,8 +376,7 @@ internal abstract class MadaraParser( } protected open suspend fun loadChapters(mangaUrl: String, document: Document): List { - - val doc = if (postreq) { + val doc = if (postReq) { val mangaId = document.select("div#manga-chapters-holder").attr("data-id") val url = "https://$domain/wp-admin/admin-ajax.php" val postdata = "action=manga_get_chapters&manga=$mangaId" @@ -388,13 +385,11 @@ internal abstract class MadaraParser( val url = mangaUrl.toAbsoluteUrl(domain).removeSuffix('/') + "/ajax/chapters/" webClient.httpPost(url, emptyMap()).parseHtml() } - val dateFormat = SimpleDateFormat(datePattern, sourceLocale) - return doc.select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirst("a") val href = a?.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") - val link = href + stylepage + val link = href + stylePage val dateText = li.selectFirst("a.c-new-tag")?.attr("title") ?: li.selectFirst(selectDate)?.text() val name = a.selectFirst("p")?.text() ?: a.ownText() MangaChapter( @@ -413,13 +408,35 @@ internal abstract class MadaraParser( } } + override suspend fun getRelatedManga(seed: Manga): List { + val doc = webClient.httpGet(seed.url.toAbsoluteUrl(domain)).parseHtml() + val root = doc.body().selectFirstOrThrow(".related-manga") + return root.select("div.related-reading-wrap").mapNotNull { div -> + val a = div.selectFirst("a") ?: return@mapNotNull null + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = href.toAbsoluteUrl(a.host ?: domain), + altTitle = null, + title = div.selectFirstOrThrow(".widget-title").text(), + author = null, + coverUrl = div.selectFirst("img")?.src().orEmpty(), + tags = emptySet(), + rating = RATING_UNKNOWN, + state = null, + isNsfw = isNsfwSource, + source = source, + ) + } + } + protected open val selectBodyPage = "div.main-col-inner div.reading-content" protected open val selectPage = "div.page-break, div.login-required" override suspend fun getPages(chapter: MangaChapter): List { val fullUrl = chapter.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() - val chapterProtector = doc.getElementById("chapter-protector-data") if (chapterProtector == null) { val root = doc.body().selectFirstOrThrow(selectBodyPage) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Ero18x.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Ero18x.kt index fe37616a9..94d2d9483 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Ero18x.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Ero18x.kt @@ -21,7 +21,7 @@ internal class Ero18x(context: MangaLoaderContext) : return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") val href = a.attrAsRelativeUrl("href") - val link = href + stylepage + val link = href + stylePage val dateText = li.selectFirst("a.c-new-tag")?.attr("title") ?: li.selectFirst(selectDate)?.text() val name = a.selectFirst("p")?.text() ?: a.ownText() MangaChapter( diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/MangaTop.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/MangaTop.kt index 474c1224f..7135e03a5 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/MangaTop.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/MangaTop.kt @@ -12,5 +12,5 @@ internal class MangaTop(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGATOP, "mangatop.site") { override val datePattern = "d MMMM yyyy" override val sourceLocale: Locale = Locale.ENGLISH - override val stylepage = "" + override val stylePage = "" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/ManhwaRaw.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/ManhwaRaw.kt index 9a72d2e54..a6c6dca13 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/ManhwaRaw.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/ManhwaRaw.kt @@ -13,13 +13,11 @@ import org.koitharu.kotatsu.parsers.util.generateUid import org.koitharu.kotatsu.parsers.util.mapChapters import org.koitharu.kotatsu.parsers.util.parseFailed import java.text.SimpleDateFormat -import java.util.Locale @MangaSourceParser("MANHWARAW", "Manhwa Raw", "", ContentType.HENTAI) internal class ManhwaRaw(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHWARAW, "manhwa-raw.com", 10) { - override val datePattern = "MMMM d" - override val sourceLocale: Locale = Locale.ENGLISH + override val datePattern = "MM/dd" override val withoutAjax = true override suspend fun getChapters(manga: Manga, doc: Document): List { @@ -27,10 +25,9 @@ internal class ManhwaRaw(context: MangaLoaderContext) : return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirst("a") val href = a?.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") - val link = href + stylepage + val link = href + stylePage val dateText = li.selectFirst("a.c-new-tag")?.attr("title") ?: li.selectFirst(selectDate)?.text() - - val name = a.selectFirst("p")?.text() ?: a.ownText() + val name = a.selectFirst("h4")?.text() ?: a.ownText() MangaChapter( id = generateUid(href), name = name, diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/ManyToonClub.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/ManyToonClub.kt index 1b562c53d..b60311418 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/ManyToonClub.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/ManyToonClub.kt @@ -10,7 +10,7 @@ import java.util.Locale @MangaSourceParser("MANYTOON_CLUB", "Many Toon .Club", "", ContentType.HENTAI) internal class ManyToonClub(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANYTOON_CLUB, "manytoon.club") { - override val postreq = true + override val postReq = true override val listUrl = "manhwa-raw/" override val tagPrefix = "manhwa-raw-genre/" override val sourceLocale: Locale = Locale.ENGLISH diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Azoranov.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Azoranov.kt index d6db69af3..d044fab92 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Azoranov.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Azoranov.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("AZORANOV", "Azoranov", "ar") +@MangaSourceParser("AZORANOV", "Azora Nov", "ar") internal class Azoranov(context: MangaLoaderContext) : MadaraParser(context, MangaSource.AZORANOV, "azoranov.com", pageSize = 10) { override val tagPrefix = "series-genre/" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/GateManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/GateManga.kt index 860333751..4814aca39 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/GateManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/GateManga.kt @@ -8,7 +8,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("GATEMANGA", "Gate Manga", "ar") internal class GateManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.GATEMANGA, "gatemanga.com") { - override val postreq = true + override val postReq = true override val datePattern = "d MMMM، yyyy" override val listUrl = "ar/" override val withoutAjax = true diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Manga_Lek.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaLekCom.kt similarity index 83% rename from src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Manga_Lek.kt rename to src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaLekCom.kt index 02e16751e..88360559a 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Manga_Lek.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaLekCom.kt @@ -6,8 +6,8 @@ import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGA_LEK", "Manga-Lek", "ar") -internal class Manga_Lek(context: MangaLoaderContext) : +internal class MangaLekCom(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGA_LEK, "manga-lek.com") { override val listUrl = "mangalek/" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaLeks.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaLeks.kt index 3fb8d0316..ff8725c2d 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaLeks.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaLeks.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class MangaLeks(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGALEKS, "mangaleks.com") { override val datePattern = "yyyy/MM/dd" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaLike.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaLike.kt index b867dd742..9411a45b0 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaLike.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaLike.kt @@ -7,4 +7,4 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGALIKE", "Manga Like", "ar") internal class MangaLike(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.MANGALIKE, "mangalike.me", pageSize = 10) + MadaraParser(context, MangaSource.MANGALIKE, "manga-like.net", pageSize = 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaTime.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaTime.kt new file mode 100644 index 000000000..eb7413eea --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/MangaTime.kt @@ -0,0 +1,12 @@ +package org.koitharu.kotatsu.parsers.site.madara.ar + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +import org.koitharu.kotatsu.parsers.MangaSourceParser +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.site.madara.MadaraParser + +@MangaSourceParser("MANGATIME", "Manga Time", "ar") +internal class MangaTime(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.MANGATIME, "mangatime.co") { + override val datePattern = "d MMMM، yyyy" +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Mangarbic.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Mangarbic.kt index 9ae000fa4..369ef62ac 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Mangarbic.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Mangarbic.kt @@ -5,9 +5,9 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANGARBIC", "Mangarbic", "ar") +@MangaSourceParser("MANGARBIC", "Manga Arabic", "ar") internal class Mangarbic(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGARBIC, "mangarabic.com") { - override val postreq = true + override val postReq = true override val datePattern = "yyyy/MM/dd" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Mangaspark.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Mangaspark.kt index 5cf927962..e82e2b0da 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Mangaspark.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Mangaspark.kt @@ -8,6 +8,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGASPARK", "Manga Spark", "ar") internal class Mangaspark(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGASPARK, "mangaspark.org", pageSize = 10) { - override val postreq = true + override val postReq = true override val datePattern = "d MMMM، yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/NijiTranslations.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/NijiTranslations.kt index 9224c7b26..3f4e9af13 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/NijiTranslations.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/NijiTranslations.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("NIJITRANSLATIONS", "Niji Translations", "ar") internal class NijiTranslations(context: MangaLoaderContext) : MadaraParser(context, MangaSource.NIJITRANSLATIONS, "niji-translations.com") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/PewPiece.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/PewPiece.kt index dfb8cd216..e39b0cd7a 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/PewPiece.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/PewPiece.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("PEWPIECE", "PewPiece", "ar") +@MangaSourceParser("PEWPIECE", "Pew Piece", "ar") internal class PewPiece(context: MangaLoaderContext) : MadaraParser(context, MangaSource.PEWPIECE, "pewpiece.com") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/AdultWebtoon.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/AdultWebtoon.kt index af58a8db1..eb76f61de 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/AdultWebtoon.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/AdultWebtoon.kt @@ -10,5 +10,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class AdultWebtoon(context: MangaLoaderContext) : MadaraParser(context, MangaSource.ADULT_WEBTOON, "adultwebtoon.com") { override val tagPrefix = "adult-webtoon-genre/" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Astrallibrary.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Astrallibrary.kt index a0d64cc27..d7caa5314 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Astrallibrary.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Astrallibrary.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class Astrallibrary(context: MangaLoaderContext) : MadaraParser(context, MangaSource.ASTRALLIBRARY, "astrallibrary.net", 18) { override val datePattern = "dd MMM" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BlogManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BlogManga.kt index bbd63e8bb..77543f156 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BlogManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BlogManga.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("BLOG_MANGA", "Blog Manga", "en") internal class BlogManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.BLOG_MANGA, "blogmanga.net") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BoysLove.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BoysLove.kt index 9ef7d7bdb..abd469380 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BoysLove.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BoysLove.kt @@ -11,5 +11,5 @@ internal class BoysLove(context: MangaLoaderContext) : MadaraParser(context, MangaSource.BOYS_LOVE, "boyslove.me", 20) { override val tagPrefix = "boyslove-genre/" override val listUrl = "boyslove/" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/CoffeeMangaTop.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/CoffeeMangaTop.kt index ac169a03f..c5bbb0eb7 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/CoffeeMangaTop.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/CoffeeMangaTop.kt @@ -110,7 +110,7 @@ internal class CoffeeMangaTop(context: MangaLoaderContext) : return doc.select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirst("a") val href = a?.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") - val link = href + stylepage + val link = href + stylePage MangaChapter( id = generateUid(href), url = link, diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/CreepyScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/CreepyScans.kt index dda2f332a..2f1f7e67e 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/CreepyScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/CreepyScans.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("CREEPYSCANS", "Creepy Scans", "en") internal class CreepyScans(context: MangaLoaderContext) : MadaraParser(context, MangaSource.CREEPYSCANS, "creepyscans.com") { - override val stylepage = "" + override val stylePage = "" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/FreeComicOnline.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/FreeComicOnline.kt index 6c6dd117e..86ba6205e 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/FreeComicOnline.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/FreeComicOnline.kt @@ -9,7 +9,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("FREECOMICONLINE", "Free Comic Online", "en", ContentType.HENTAI) internal class FreeComicOnline(context: MangaLoaderContext) : MadaraParser(context, MangaSource.FREECOMICONLINE, "freecomiconline.me") { - override val postreq = true + override val postReq = true override val listUrl = "comic/" override val tagPrefix = "comic-genre/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/GdScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/GdScans.kt index 2ed02980a..d730d17f0 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/GdScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/GdScans.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("GDSCANS", "GdScans", "en") +@MangaSourceParser("GDSCANS", "Gd Scans", "en") internal class GdScans(context: MangaLoaderContext) : MadaraParser(context, MangaSource.GDSCANS, "gdscans.com", 10) { override val tagPrefix = "webtoon-genre/" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/GourmetScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/GourmetScans.kt index f2b9d8d5b..38f3e8099 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/GourmetScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/GourmetScans.kt @@ -10,5 +10,5 @@ internal class GourmetScans(context: MangaLoaderContext) : MadaraParser(context, MangaSource.GOURMETSCANS, "gourmetscans.net") { override val listUrl = "project/" override val tagPrefix = "genre/" - override val stylepage = "" + override val stylePage = "" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HManhwa.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HManhwa.kt index eef14c7c1..04ef7cfa3 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HManhwa.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HManhwa.kt @@ -6,11 +6,11 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("HMANHWA", "HManhwa", "en", ContentType.HENTAI) +@MangaSourceParser("HMANHWA", "H Manhwa", "en", ContentType.HENTAI) internal class HManhwa(context: MangaLoaderContext) : MadaraParser(context, MangaSource.HMANHWA, "hmanhwa.com") { override val tagPrefix = "manhwa-genre/" override val listUrl = "manhwa/" override val datePattern = "dd MMM" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HScans.kt index 833e79c0f..e1302a7ed 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HScans.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("HSCANS", "HScans", "en") +@MangaSourceParser("HSCANS", "H Scans", "en") internal class HScans(context: MangaLoaderContext) : MadaraParser(context, MangaSource.HSCANS, "hscans.com", 10) { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaiManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaiManga.kt index 5706c2c53..e249865c9 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaiManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaiManga.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("HENTAIMANGA", "Hentai Manga", "en", ContentType.HENTAI) internal class HentaiManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.HENTAIMANGA, "hentaimanga.me", 36) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaiWebtoon.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaiWebtoon.kt index cd1a78fb5..3b02167ac 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaiWebtoon.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaiWebtoon.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("HENTAIWEBTOON", "Hentai Webtoon", "en", ContentType.HENTAI) internal class HentaiWebtoon(context: MangaLoaderContext) : MadaraParser(context, MangaSource.HENTAIWEBTOON, "hentaiwebtoon.com") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaixComic.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaixComic.kt index cef04f229..bd4c2877e 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaixComic.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaixComic.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("HENTAIXCOMIC", "Hentai x Comic", "en", ContentType.HENTAI) internal class HentaixComic(context: MangaLoaderContext) : MadaraParser(context, MangaSource.HENTAIXCOMIC, "hentaixcomic.com", 16) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaixYuri.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaixYuri.kt index 2cfbbe13e..2968cd7b7 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaixYuri.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HentaixYuri.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("HENTAIXYURI", "Hentai x Yuri", "en", ContentType.HENTAI) internal class HentaixYuri(context: MangaLoaderContext) : MadaraParser(context, MangaSource.HENTAIXYURI, "hentaixyuri.com", 16) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Hentaixdickgirl.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Hentaixdickgirl.kt index f35d1c3c5..e30f49624 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Hentaixdickgirl.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Hentaixdickgirl.kt @@ -14,15 +14,15 @@ import java.text.SimpleDateFormat @MangaSourceParser("HENTAIXDICKGIRL", "Hentai x Dickgirl", "en", ContentType.HENTAI) internal class Hentaixdickgirl(context: MangaLoaderContext) : MadaraParser(context, MangaSource.HENTAIXDICKGIRL, "hentaixdickgirl.com", 16) { + override val postReq = true - override val postreq = true override suspend fun getChapters(manga: Manga, doc: Document): List { val root2 = doc.body().selectFirstOrThrow("div.listing-chapters_wrap") val dateFormat = SimpleDateFormat(datePattern, sourceLocale) return root2.select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirst("a") val href = a?.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") - val link = href + stylepage + val link = href + stylePage val dateText = li.selectFirst("a.c-new-tag")?.attr("title") ?: li.selectFirst(selectDate)?.text() val name = a.selectFirst("p")?.text() ?: a.ownText() MangaChapter( diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/InstaManhwa.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/InstaManhwa.kt index 7249c8faf..c10c7b1a7 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/InstaManhwa.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/InstaManhwa.kt @@ -14,7 +14,7 @@ internal class InstaManhwa(context: MangaLoaderContext) : MadaraParser(context, MangaSource.INSTAMANHWA, "www.instamanhwa.com", 15) { override val tagPrefix = "genre/" override val listUrl = "latest/" - override val postreq = true + override val postReq = true override val datePattern = "d MMMM, yyyy" override val sortOrders: Set = EnumSet.of( @@ -113,7 +113,7 @@ internal class InstaManhwa(context: MangaLoaderContext) : return doc.select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirst("a") val href = a?.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") - val link = href + stylepage + val link = href + stylePage val dateText = li.selectFirst("a.c-new-tag")?.attr("title") ?: li.selectFirst(selectDate)?.text() val name = a.selectFirst("p")?.text() ?: a.ownText() MangaChapter( diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/IsekaiScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/IsekaiScan.kt index af835269f..7d35f1a6b 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/IsekaiScan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/IsekaiScan.kt @@ -113,7 +113,7 @@ internal class IsekaiScan(context: MangaLoaderContext) : return doc.select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirst("a") val href = a?.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") - val link = href + stylepage + val link = href + stylePage MangaChapter( id = generateUid(href), url = link, diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Itsyourightmanhua.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Itsyourightmanhua.kt index 84a79ebfc..a53ba4fb3 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Itsyourightmanhua.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Itsyourightmanhua.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("ITSYOURIGHTMANHUA", "Itsyourightmanhua", "en") +@MangaSourceParser("ITSYOURIGHTMANHUA", "Its You Right Manhua", "en") internal class Itsyourightmanhua(context: MangaLoaderContext) : MadaraParser(context, MangaSource.ITSYOURIGHTMANHUA, "itsyourightmanhua.com", 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Jaiminisbox.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Jaiminisbox.kt index 4964cd94e..543cef5ea 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Jaiminisbox.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Jaiminisbox.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("JAIMINISBOX", "Jaiminisbox", "en") +@MangaSourceParser("JAIMINISBOX", "Jaiminis Box", "en") internal class Jaiminisbox(context: MangaLoaderContext) : MadaraParser(context, MangaSource.JAIMINISBOX, "jaiminisbox.net") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/JiManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/JiManga.kt index a3f9d6551..180219aaf 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/JiManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/JiManga.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("JIMANGA", "JiManga", "en") +@MangaSourceParser("JIMANGA", "Ji Manga", "en") internal class JiManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.JIMANGA, "jimanga.com") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/LoliconMobi.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/LoliconMobi.kt index e33703960..444305621 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/LoliconMobi.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/LoliconMobi.kt @@ -9,6 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("LOLICONMOBI", "Lolicon Mobi", "en", ContentType.HENTAI) internal class LoliconMobi(context: MangaLoaderContext) : MadaraParser(context, MangaSource.LOLICONMOBI, "lolicon.mobi") { - override val postreq = true + override val postReq = true override val tagPrefix = "lolicon-genre/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaBob.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaBob.kt index 147232064..d7a063178 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaBob.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaBob.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGABOB", "Manga Bob", "en") internal class MangaBob(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGABOB, "mangabob.com") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaClashTv.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaClashTv.kt index 9b7010f66..658578940 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaClashTv.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaClashTv.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class MangaClashTv(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGACLASH_TV, "mangaclash.tv", pageSize = 10) { override val datePattern = "MM/dd/yyyy" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDass.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDass.kt index 2b7e50054..6cab64d5f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDass.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDass.kt @@ -146,7 +146,7 @@ internal class MangaDass(context: MangaLoaderContext) : return root2.select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirst("a") val href = a?.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") - val link = href + stylepage + val link = href + stylePage val dateText = li.selectFirst("a.c-new-tag")?.attr("title") ?: li.selectFirst(selectDate)?.text() val name = a.selectFirst("p")?.text() ?: a.ownText() MangaChapter( diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDinoTop.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDinoTop.kt index bbf93a7f9..84df063c1 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDinoTop.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDinoTop.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGADINOTOP", "Manga Dino", "en") internal class MangaDinoTop(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGADINOTOP, "mangadino.top", 10) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDna.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDna.kt index 8599d9e8c..ba7af66b6 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDna.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDna.kt @@ -144,7 +144,7 @@ internal class MangaDna(context: MangaLoaderContext) : return root2.select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirst("a") val href = a?.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") - val link = href + stylepage + val link = href + stylePage val dateText = li.selectFirst("a.c-new-tag")?.attr("title") ?: li.selectFirst(selectDate)?.text() val name = a.selectFirst("p")?.text() ?: a.ownText() MangaChapter( diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaEffect.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaEffect.kt index 3dd415aec..838bcfb92 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaEffect.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaEffect.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANGAEFFECT", "MangaEffect", "en") +@MangaSourceParser("MANGAEFFECT", "Manga Effect", "en") internal class MangaEffect(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAEFFECT, "mangaeffect.com") { override val datePattern = "dd.MM.yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaForFree.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaForFree.kt index b014baf1e..5994f94be 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaForFree.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaForFree.kt @@ -9,6 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGAFORFREE", "Manga For Free", "en", ContentType.HENTAI) internal class MangaForFree(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAFORFREE, "mangaforfree.com", 10) { - - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaFoxFull.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaFoxFull.kt index 20e8a6656..4d5d8d730 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaFoxFull.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaFoxFull.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGAFOXFULL", "Manga Fox Full", "en") internal class MangaFoxFull(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAFOXFULL, "mangafoxfull.com") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaFreak.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaFreak.kt index 9a7475773..47282397d 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaFreak.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaFreak.kt @@ -8,6 +8,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGAFREAK", "Manga Freak", "en") internal class MangaFreak(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAFREAK, "mangafreak.online") { - override val postreq = true + override val postReq = true override val datePattern = "dd MMMM، yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaLeveling.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaLeveling.kt index c0286319a..c3c23a608 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaLeveling.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaLeveling.kt @@ -8,7 +8,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGALEVELING", "Manga Leveling", "en") internal class MangaLeveling(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGALEVELING, "mangaleveling.com", 30) { - override val postreq = true + override val postReq = true override val tagPrefix = "comics-genre/" override val listUrl = "comics/" override val datePattern = "MM/dd/yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaManhua.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaManhua.kt index afced82a4..8f5e52951 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaManhua.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaManhua.kt @@ -7,6 +7,4 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGA_MANHUA", "Manga Manhua", "en") internal class MangaManhua(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.MANGA_MANHUA, "mangamanhua.online", pageSize = 10) { - override val datePattern = "d MMMM، yyyy" -} + MadaraParser(context, MangaSource.MANGA_MANHUA, "mangaonlineteam.com", pageSize = 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaOwlBlog.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaOwlBlog.kt index e5322ba90..5e9cd4cbd 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaOwlBlog.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaOwlBlog.kt @@ -6,8 +6,8 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANGAOWLBLOG", "MangaOwl .Blog", "en", ContentType.HENTAI) +@MangaSourceParser("MANGAOWLBLOG", "Manga Owl .Blog", "en", ContentType.HENTAI) internal class MangaOwlBlog(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAOWLBLOG, "mangaowl.blog", 20) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaOwlIo.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaOwlIo.kt index 1481b6a67..e9df6b0ff 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaOwlIo.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaOwlIo.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANGAOWL_IO", "MangaOwl .Io", "en") +@MangaSourceParser("MANGAOWL_IO", "Manga Owl .Io", "en") internal class MangaOwlIo(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAOWL_IO, "mangaowl.io") { override val listUrl = "mangaowl-all/" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaPure.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaPure.kt index f735fc92a..ea69adb9f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaPure.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaPure.kt @@ -112,7 +112,7 @@ internal class MangaPure(context: MangaLoaderContext) : return doc.select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirst("a") val href = a?.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") - val link = href + stylepage + val link = href + stylePage MangaChapter( id = generateUid(href), url = link, diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaRawInfo.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaRawInfo.kt index b0ed9bbb2..b5545ad23 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaRawInfo.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaRawInfo.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGARAWINFO", "Manga-Raw .Info", "en") internal class MangaRawInfo(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGARAWINFO, "manga-raw.info", 20) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaRocky.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaRocky.kt index 5ea77b9ed..52b0661f0 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaRocky.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaRocky.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGAROCKY", "Manga Rocky", "en") internal class MangaRocky(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAROCKY, "mangarocky.com") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaUpdatesTop.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaUpdatesTop.kt index 80ea82112..8580bc1ee 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaUpdatesTop.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaUpdatesTop.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGAUPDATESTOP", "Manga Updates .Top", "en") internal class MangaUpdatesTop(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAUPDATESTOP, "mangaupdates.top", 10) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manganelo.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manganelo.kt index 774b2e5e8..d4b9cdad9 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manganelo.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manganelo.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGANELO", "Manga Nelo", "en") internal class Manganelo(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGANELO, "manganelo.biz", 10) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaowlOne.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaowlOne.kt index f09e08ab4..6b99600a3 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaowlOne.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaowlOne.kt @@ -6,8 +6,8 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANGAOWL_ONE", "MangaOwl .One", "en", ContentType.HENTAI) +@MangaSourceParser("MANGAOWL_ONE", "Manga Owl .One", "en", ContentType.HENTAI) internal class MangaowlOne(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAOWL_ONE, "mangaowl.one") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Mangax1.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Mangax1.kt index db4ebfedc..0a1e68265 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Mangax1.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Mangax1.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGAX1", "MangaX1", "en") internal class Mangax1(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAX1, "mangax1.com") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhuaScanInfo.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhuaScanInfo.kt index a8966ed43..2a357c5ed 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhuaScanInfo.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhuaScanInfo.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANHUASCANINFO", "Manhua Scan .Info", "en") internal class ManhuaScanInfo(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHUASCANINFO, "manhuascan.info", 10) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuaes.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuaes.kt index efbb7c64c..7e7b38787 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuaes.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuaes.kt @@ -5,8 +5,8 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANHUAES", "Manhuaes", "en") +@MangaSourceParser("MANHUAES", "ManhuaEs", "en") internal class Manhuaes(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHUAES, "manhuaes.com") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuaga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuaga.kt index cccf6dd21..daa8091e1 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuaga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuaga.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANHUAGA", "Manhuaga", "en") +@MangaSourceParser("MANHUAGA", "ManhuaGa", "en") internal class Manhuaga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHUAGA, "manhuaga.com") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuasy.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuasy.kt index 285e11a56..10691108e 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuasy.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuasy.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANHUASY", "Manhuasy", "en") +@MangaSourceParser("MANHUASY", "ManhuaSy", "en") internal class Manhuasy(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHUASY, "www.manhuasy.com") { override val listUrl = "manhua/" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuaus.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuaus.kt index 301d224e1..168e5a420 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuaus.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuaus.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANHUAUS", "Manhuaus", "en") +@MangaSourceParser("MANHUAUS", "ManhuaUs", "en") internal class Manhuaus(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHUAUS, "manhuaus.com") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwa18App.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwa18App.kt index 5a0f35447..c37801fe3 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwa18App.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwa18App.kt @@ -6,8 +6,8 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANHWA18APP", "Manhwa18 .App", "en", ContentType.HENTAI) +@MangaSourceParser("MANHWA18APP", "Manhwa 18 .App", "en", ContentType.HENTAI) internal class Manhwa18App(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHWA18APP, "manhwa18.app") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwa18Org.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwa18Org.kt index 954a0a152..a71c3f867 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwa18Org.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwa18Org.kt @@ -6,9 +6,8 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANHWA18ORG", "Manhwa18 .Org", "en", ContentType.HENTAI) +@MangaSourceParser("MANHWA18ORG", "Manhwa 18 .Org", "en", ContentType.HENTAI) internal class Manhwa18Org(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHWA18ORG, "manhwa18.org") { - - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwa2Read.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwa2Read.kt index f586ae743..d2cd8df5e 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwa2Read.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwa2Read.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANHWA2READ", "Manhwa2Read", "en") +@MangaSourceParser("MANHWA2READ", "Manhwa 2 Read", "en") internal class Manhwa2Read(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHWA2READ, "manhwa2read.com") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaRawCom.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaRawCom.kt index 8702ee8e2..3f80f3023 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaRawCom.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaRawCom.kt @@ -9,7 +9,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANHWARAW_COM", "Manhwa Raw .Com", "en", ContentType.HENTAI) internal class ManhwaRawCom(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHWARAW_COM, "manhwaraw.com") { - override val postreq = true + override val postReq = true override val listUrl = "manhwa-raw/" override val tagPrefix = "manhwa-raw-genre/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaTop.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaTop.kt index 785f17140..d72be859e 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaTop.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaTop.kt @@ -13,7 +13,7 @@ import java.text.SimpleDateFormat internal class ManhwaTop(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHWATOP, "manhwatop.com") { - override val postreq = true + override val postReq = true override suspend fun loadChapters(mangaUrl: String, document: Document): List { @@ -27,7 +27,7 @@ internal class ManhwaTop(context: MangaLoaderContext) : return doc.select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirst("a") val href = a?.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") - val link = href + stylepage + val link = href + stylePage val dateText = li.selectFirst("a.c-new-tag")?.attr("title") ?: li.selectFirst(selectDate)?.text() val name = a.selectFirst("p")?.text() ?: a.ownText() val dateText2 = if (dateText != "Complete") { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwaden.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwaden.kt new file mode 100644 index 000000000..e7c23b9d2 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwaden.kt @@ -0,0 +1,32 @@ +package org.koitharu.kotatsu.parsers.site.madara.en + +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.MangaChapter +import org.koitharu.kotatsu.parsers.model.MangaPage +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.site.madara.MadaraParser +import org.koitharu.kotatsu.parsers.util.* + +@MangaSourceParser("MANHWADEN", "Manhwa Den", "en", ContentType.HENTAI) +internal class Manhwaden(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.MANHWADEN, "www.manhwaden.com", 10) { + + override val selectPage = "p img[src]" + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + val root = doc.body().selectFirstOrThrow(selectBodyPage) + return root.select(selectPage).map { img -> + val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found") + MangaPage( + id = generateUid(url), + url = url, + preview = null, + source = source, + ) + } + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwasco.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwasco.kt index 84af3a407..2288f1e2f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwasco.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwasco.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANHWASCO", "Manhwasco", "en") +@MangaSourceParser("MANHWASCO", "Manhwa Sco", "en") internal class Manhwasco(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHWASCO, "manhwasco.net") { override val selectGenre = "div.mg_genres a" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyComic.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyComic.kt index 646a6d8ce..7615083e7 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyComic.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyComic.kt @@ -9,6 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANYCOMIC", "Many Comic", "en", ContentType.HENTAI) internal class ManyComic(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANYCOMIC, "manycomic.com") { - override val postreq = true + override val postReq = true override val tagPrefix = "comic-genre/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MilfToon.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MilfToon.kt index ac4bb7448..392969198 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MilfToon.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MilfToon.kt @@ -9,6 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MILFTOON", "Milf Toon", "en", ContentType.HENTAI) internal class MilfToon(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MILFTOON, "milftoon.xxx", 20) { - override val postreq = true + override val postReq = true override val datePattern = "d MMMM, yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MortalsGroove.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MortalsGroove.kt index e6f8810e0..6ee8e0e44 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MortalsGroove.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MortalsGroove.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MORTALSGROOVE", "Mortals Groove", "en") internal class MortalsGroove(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MORTALSGROOVE, "mortalsgroove.com") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MurimScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MurimScan.kt index f47b86ff1..309b9a3cb 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MurimScan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MurimScan.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class MurimScan(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MURIMSCAN, "murimscan.run", 100) { override val withoutAjax = true - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/NightComic.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/NightComic.kt index a61af9738..3ca23d5a2 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/NightComic.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/NightComic.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("NIGHTCOMIC", "Night Comic", "en") internal class NightComic(context: MangaLoaderContext) : MadaraParser(context, MangaSource.NIGHTCOMIC, "www.nightcomic.com") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Novelmic.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Novelmic.kt index 9138e719b..77036416f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Novelmic.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Novelmic.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("NOVELMIC", "Novel Mic", "en") internal class Novelmic(context: MangaLoaderContext) : MadaraParser(context, MangaSource.NOVELMIC, "novelmic.com", 20) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Painfulnightz.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Painfulnightz.kt index 3ccfa15b5..fb7629ecb 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Painfulnightz.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Painfulnightz.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("PAINFULNIGHTZ", "Painfulnightz", "en") +@MangaSourceParser("PAINFULNIGHTZ", "Painful Nightz", "en") internal class Painfulnightz(context: MangaLoaderContext) : MadaraParser(context, MangaSource.PAINFULNIGHTZ, "painfulnightz.com") { override val datePattern = "d MMMM" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/PawManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/PawManga.kt index 3774e6da2..b7d399322 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/PawManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/PawManga.kt @@ -6,6 +6,6 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("PAWMANGA", "PawManga", "en", ContentType.HENTAI) +@MangaSourceParser("PAWMANGA", "Paw Manga", "en", ContentType.HENTAI) internal class PawManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.PAWMANGA, "pawmanga.com", 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/PetrotechSociety.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/PetrotechSociety.kt index d949bf70c..27387633c 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/PetrotechSociety.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/PetrotechSociety.kt @@ -6,8 +6,8 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("PETROTECHSOCIETY", "PetrotechSociety", "en", ContentType.HENTAI) +@MangaSourceParser("PETROTECHSOCIETY", "Petrotech Society", "en", ContentType.HENTAI) internal class PetrotechSociety(context: MangaLoaderContext) : MadaraParser(context, MangaSource.PETROTECHSOCIETY, "www.petrotechsociety.org", pageSize = 10) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/PlatinumScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/PlatinumScans.kt index ad8b0e357..4558ffcd6 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/PlatinumScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/PlatinumScans.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("PLATINUMSCANS", "Platinum Scans", "en") internal class PlatinumScans(context: MangaLoaderContext) : MadaraParser(context, MangaSource.PLATINUMSCANS, "platinumscans.com", pageSize = 10) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ReadManhua.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ReadManhua.kt index 4f11f9b07..9e88d6a45 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ReadManhua.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ReadManhua.kt @@ -9,6 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("READMANHUA", "Read Manhua", "en", ContentType.HENTAI) internal class ReadManhua(context: MangaLoaderContext) : MadaraParser(context, MangaSource.READMANHUA, "readmanhua.net", 20) { - override val postreq = true + override val postReq = true override val datePattern = "d MMM yy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Rio2MangaNet.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Rio2MangaNet.kt index 63d0ad97d..af4a6dcdb 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Rio2MangaNet.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Rio2MangaNet.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("RIO2MANGANET", "Rio2Manga .Net", "en") +@MangaSourceParser("RIO2MANGANET", "Rio 2 Manga .Net", "en") internal class Rio2MangaNet(context: MangaLoaderContext) : MadaraParser(context, MangaSource.RIO2MANGANET, "rio2manga.net", 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/SectScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/SectScans.kt new file mode 100644 index 000000000..dc4f56a73 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/SectScans.kt @@ -0,0 +1,12 @@ +package org.koitharu.kotatsu.parsers.site.madara.en + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +import org.koitharu.kotatsu.parsers.MangaSourceParser +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.site.madara.MadaraParser + +@MangaSourceParser("SECTSCANS", "Sect Scans", "en") +internal class SectScans(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.SECTSCANS, "sectscans.com") { + override val listUrl = "comics/" +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ShootingStarScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ShootingStarScans.kt index b8604002f..1937b2759 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ShootingStarScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ShootingStarScans.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("SHOOTINGSTARSCANS", "ShootingStar Scans", "en") +@MangaSourceParser("SHOOTINGSTARSCANS", "Shooting Star Scans", "en") internal class ShootingStarScans(context: MangaLoaderContext) : MadaraParser(context, MangaSource.SHOOTINGSTARSCANS, "shootingstarscans.com") { override val tagPrefix = "manga-tag/" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/StkissMangaBlog.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/StkissMangaBlog.kt index adc3dbcdb..3d5825e64 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/StkissMangaBlog.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/StkissMangaBlog.kt @@ -5,8 +5,8 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("STKISSMANGABLOG", "StkissManga .Blog", "en") +@MangaSourceParser("STKISSMANGABLOG", "St kiss Manga .Blog", "en") internal class StkissMangaBlog(context: MangaLoaderContext) : MadaraParser(context, MangaSource.STKISSMANGABLOG, "1stkissmanga.blog", 10) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/StkissMangaCom.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/StkissMangaCom.kt index 455df8bab..be5fa737e 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/StkissMangaCom.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/StkissMangaCom.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("STKISSMANGA_COM", "1st Kiss-Manga .Com", "en") +@MangaSourceParser("STKISSMANGA_COM", "1St Kiss-Manga .Com", "en") internal class StkissMangaCom(context: MangaLoaderContext) : MadaraParser(context, MangaSource.STKISSMANGA_COM, "1stkiss-manga.com", 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/StkissMangaTv.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/StkissMangaTv.kt index 72065b638..74efcd765 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/StkissMangaTv.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/StkissMangaTv.kt @@ -5,8 +5,8 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("STKISSMANGA_TV", "1stKissManga .Tv", "en") +@MangaSourceParser("STKISSMANGA_TV", "1St Kiss Manga .Tv", "en") internal class StkissMangaTv(context: MangaLoaderContext) : MadaraParser(context, MangaSource.STKISSMANGA_TV, "1stkissmanga.tv", 20) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/SumManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/SumManga.kt index 37cae7f26..69a938fc7 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/SumManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/SumManga.kt @@ -6,6 +6,6 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("SUMMANGA", "SumManga", "en", ContentType.HENTAI) +@MangaSourceParser("SUMMANGA", "Sum Manga", "en", ContentType.HENTAI) internal class SumManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.SUMMANGA, "summanga.com") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Theguildscans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Theguildscans.kt index 6f5584a68..40c96cb18 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Theguildscans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Theguildscans.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("THEGUILDSCANS", "The Guild Scans", "en") internal class Theguildscans(context: MangaLoaderContext) : MadaraParser(context, MangaSource.THEGUILDSCANS, "theguildscans.com") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/WebComic.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/WebComic.kt index cdead5f08..778c45121 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/WebComic.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/WebComic.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("WEBCOMIC", "WebComic", "en") internal class WebComic(context: MangaLoaderContext) : MadaraParser(context, MangaSource.WEBCOMIC, "webcomic.me") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Webtoon.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Webtoon.kt index f4ff0b566..ee109787f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Webtoon.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Webtoon.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class Webtoon(context: MangaLoaderContext) : MadaraParser(context, MangaSource.WEBTOON, "webtoon.uk", 20) { override val tagPrefix = "manhwa-genre/" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Webtoons.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Webtoons.kt index a2fed1139..97186c61c 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Webtoons.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Webtoons.kt @@ -10,5 +10,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class Webtoons(context: MangaLoaderContext) : MadaraParser(context, MangaSource.WEBTOONS, "webtoons.top", 20) { override val listUrl = "read/" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/YaoiMobi.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/YaoiMobi.kt index 57b9b67f1..29365ed65 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/YaoiMobi.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/YaoiMobi.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("YAOIMOBI", "Yaoi .Mobi", "en", ContentType.HENTAI) internal class YaoiMobi(context: MangaLoaderContext) : MadaraParser(context, MangaSource.YAOIMOBI, "yaoi.mobi") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ZuttoManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ZuttoManga.kt index a2944ffb0..46385137c 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ZuttoManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ZuttoManga.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("ZUTTOMANGA", "Zutto Manga", "en") internal class ZuttoManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.ZUTTOMANGA, "zuttomanga.com") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Copypastescan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Copypastescan.kt index 92f2114a5..9deab7772 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Copypastescan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Copypastescan.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("COPYPASTESCAN", "CopyPaste Scan", "es") +@MangaSourceParser("COPYPASTESCAN", "Copy Paste Scan", "es") internal class Copypastescan(context: MangaLoaderContext) : MadaraParser(context, MangaSource.COPYPASTESCAN, "copypastescan.xyz", 10) { override val datePattern = "d MMMM, yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/KoinoboriScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/KoinoboriScan.kt index edfc78855..524703a01 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/KoinoboriScan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/KoinoboriScan.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("KOINOBORISCAN", "Koinobori Scan", "es") internal class KoinoboriScan(context: MangaLoaderContext) : MadaraParser(context, MangaSource.KOINOBORISCAN, "koinoboriscan.com") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Lectorunitoon.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Lectorunitoon.kt index dddedc907..9d0fc263c 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Lectorunitoon.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Lectorunitoon.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("LECTORUNITOON", "Lectorunitoon", "es") +@MangaSourceParser("LECTORUNITOON", "Lectoruni Toon", "es") internal class Lectorunitoon(context: MangaLoaderContext) : MadaraParser(context, MangaSource.LECTORUNITOON, "lectorunitoon.com", 10) { override val tagPrefix = "generos/" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Mangaxico.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Mangaxico.kt index c65509d95..338a193c3 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Mangaxico.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Mangaxico.kt @@ -6,6 +6,6 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANGAXICO", "Mangaxico", "es", ContentType.HENTAI) +@MangaSourceParser("MANGAXICO", "Manga Xico", "es", ContentType.HENTAI) internal class Mangaxico(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAXICO, "mangaxico.com", 24) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/AiyuMangaScanlation.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/ManhuaFenix.kt similarity index 50% rename from src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/AiyuMangaScanlation.kt rename to src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/ManhuaFenix.kt index baadc6d5d..8003a65c8 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/AiyuMangaScanlation.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/ManhuaFenix.kt @@ -5,9 +5,8 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("AIYUMANGASCANLATION", "Aiyu Manga", "es") -internal class AiyuMangaScanlation(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.AIYUMANGASCANLATION, "aiyumanga.com") { - override val datePattern = "MM/dd/yyyy" - override val listUrl = "series/" +@MangaSourceParser("MANHUAFENIX", "Manhua Fenix", "es") +internal class ManhuaFenix(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.MANHUAFENIX, "manhua-fenix.com") { + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/ManhwaEs.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/ManhwaEs.kt index 5c455c4e3..112d29106 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/ManhwaEs.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/ManhwaEs.kt @@ -20,7 +20,7 @@ internal class ManhwaEs(context: MangaLoaderContext) : return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") val href = a.attrAsRelativeUrl("href") - val link = href + stylepage + val link = href + stylePage val dateText = li.selectFirst("a.c-new-tag")?.attr("title") ?: li.selectFirst(selectDate)?.text() val name = li.selectFirstOrThrow(".mini-letters a").text() diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/ManhwaLatino.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/ManhwaLatino.kt index 151c9171b..0314d91fd 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/ManhwaLatino.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/ManhwaLatino.kt @@ -24,7 +24,7 @@ internal class ManhwaLatino(context: MangaLoaderContext) : return root2.select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirst("a") val href = a?.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") - val link = href + stylepage + val link = href + stylePage val dateText = li.selectFirst("a.c-new-tag")?.attr("title") ?: li.selectFirst(selectDate)?.text() val dateText2 = if (dateText == "¡Recién publicado!") { "1 mins ago" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/NoblesseTranslations.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/NoblesseTranslations.kt index 8978664e3..fe5a4e4d4 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/NoblesseTranslations.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/NoblesseTranslations.kt @@ -7,6 +7,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("NOBLESSETRANSLATIONS", "Noblesse Translations", "es") internal class NoblesseTranslations(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.NOBLESSETRANSLATIONS, "www.noblessetranslations.com") { + MadaraParser(context, MangaSource.NOBLESSETRANSLATIONS, "noblessetranslations.com") { override val datePattern = "d MMMM, yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/RagnarokScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/RagnarokScan.kt index 5d29c47a8..e7653d8fa 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/RagnarokScan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/RagnarokScan.kt @@ -8,7 +8,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("RAGNAROKSCAN", "Ragnarok Scan", "es") internal class RagnarokScan(context: MangaLoaderContext) : MadaraParser(context, MangaSource.RAGNAROKSCAN, "ragnarokscan.com") { - override val stylepage = "" + override val stylePage = "" override val listUrl = "series/" override val tagPrefix = "genero/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/RightdarkScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/RightdarkScan.kt index 2fbd26c42..1e15a2fda 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/RightdarkScan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/RightdarkScan.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("RIGHTDARKSCAN", "Rightdark Scan", "es") +@MangaSourceParser("RIGHTDARKSCAN", "Right Dark Scan", "es") internal class RightdarkScan(context: MangaLoaderContext) : MadaraParser(context, MangaSource.RIGHTDARKSCAN, "rightdark-scan.com", 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Stickhorse.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Stickhorse.kt index c92891adb..1a0eb868f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Stickhorse.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/Stickhorse.kt @@ -8,5 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("STICKHORSE", "Stickhorse", "es") internal class Stickhorse(context: MangaLoaderContext) : MadaraParser(context, MangaSource.STICKHORSE, "www.stickhorse.cl") { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TempleScanEsp.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TempleScanEsp.kt index ffccc7d2b..053ee3c4b 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TempleScanEsp.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TempleScanEsp.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("TEMPLESCANESP", "TempleScanEsp", "es", ContentType.HENTAI) +@MangaSourceParser("TEMPLESCANESP", "Temple Scan Esp", "es", ContentType.HENTAI) internal class TempleScanEsp(context: MangaLoaderContext) : MadaraParser(context, MangaSource.TEMPLESCANESP, "templescanesp.com") { override val listUrl = "series/" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TmoManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TmoManga.kt index 6bf48deea..31c36c110 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TmoManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TmoManga.kt @@ -31,7 +31,8 @@ internal class TmoManga(context: MangaLoaderContext) : ): List { val tag = tags.oneOrThrowIfMany() val url = buildString { - append("https://$domain") + append("https://") + append(domain) when { !query.isNullOrEmpty() -> { append("/$listUrl") @@ -86,7 +87,7 @@ internal class TmoManga(context: MangaLoaderContext) : return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") val href = a.attrAsRelativeUrl("href") - val link = href + stylepage + val link = href + stylePage val name = a.selectFirst("p")?.text() ?: a.ownText() MangaChapter( id = generateUid(href), diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TopComicPorno.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TopComicPorno.kt index 24435d702..f43b8fac1 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TopComicPorno.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TopComicPorno.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("TOPCOMICPORNO", "TopComicPorno", "es", ContentType.HENTAI) +@MangaSourceParser("TOPCOMICPORNO", "Top Comic Porno", "es", ContentType.HENTAI) internal class TopComicPorno(context: MangaLoaderContext) : MadaraParser(context, MangaSource.TOPCOMICPORNO, "topcomicporno.com", 18) { override val datePattern = "MMM dd, yy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/FrScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/FrScan.kt index 204eedf02..50ac406b4 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/FrScan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/FrScan.kt @@ -4,7 +4,10 @@ import org.koitharu.kotatsu.parsers.MangaLoaderContext import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser +import java.util.Locale @MangaSourceParser("FRSCAN", "Fr-Scan", "fr") internal class FrScan(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.FRSCAN, "fr-scan.cc") + MadaraParser(context, MangaSource.FRSCAN, "fr-scan.cc") { + override val sourceLocale: Locale = Locale.ENGLISH +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/HhentaiFr.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/HhentaiFr.kt index 200095081..3d7a3bb92 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/HhentaiFr.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/HhentaiFr.kt @@ -8,7 +8,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser import org.koitharu.kotatsu.parsers.util.domain import org.koitharu.kotatsu.parsers.util.insertCookies -@MangaSourceParser("HHENTAIFR", "Hhentai", "fr", ContentType.HENTAI) +@MangaSourceParser("HHENTAIFR", "H Hentai", "fr", ContentType.HENTAI) internal class HhentaiFr(context: MangaLoaderContext) : MadaraParser(context, MangaSource.HHENTAIFR, "hhentai.fr") { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/Kataitake.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/Kataitake.kt index 783e1dbf1..a6fc82595 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/Kataitake.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/Kataitake.kt @@ -11,5 +11,5 @@ internal class Kataitake(context: MangaLoaderContext) : MadaraParser(context, MangaSource.KATAITAKE, "www.kataitake.fr", 10) { override val datePattern = "dd/MM/yyyy" override val tagPrefix = "genre/" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/Readergen.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/Readergen.kt index ce7c32b22..90b3eb97c 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/Readergen.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/Readergen.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("READERGEN", "Readergen", "fr") +@MangaSourceParser("READERGEN", "Reader Gen", "fr") internal class Readergen(context: MangaLoaderContext) : MadaraParser(context, MangaSource.READERGEN, "fr.readergen.fr", 18) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/ScantradVf.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/ScantradVf.kt index 6ac8ab291..f64523999 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/ScantradVf.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/ScantradVf.kt @@ -7,7 +7,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("SCANTRADVF", "Scantrad-Vf", "fr") internal class ScantradVf(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.SCANTRADVF, "scantrad-vf.co") { + MadaraParser(context, MangaSource.SCANTRADVF, "scantrad-vf.me") { override val datePattern = "d MMMM yyyy" override val tagPrefix = "genre/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/GourmetScansId.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/GourmetScansId.kt index cce12a057..8313204d0 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/GourmetScansId.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/GourmetScansId.kt @@ -10,5 +10,5 @@ internal class GourmetScansId(context: MangaLoaderContext) : MadaraParser(context, MangaSource.GOURMETSCANS_ID, "id.gourmetscans.net") { override val listUrl = "project/" override val tagPrefix = "genre/" - override val stylepage = "" + override val stylePage = "" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Komiksay.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Komiksay.kt index 7f7cab2f6..51a58c8d8 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Komiksay.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Komiksay.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser import java.util.Locale -@MangaSourceParser("KOMIKSA", "Komiksay", "id") +@MangaSourceParser("KOMIKSA", "Komik Say", "id") internal class Komiksay(context: MangaLoaderContext) : MadaraParser(context, MangaSource.KOMIKSA, "komiksay.site") { override val tagPrefix = "komik-genre/" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Mgkomik.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Mgkomik.kt index dea68f671..a63d63d3d 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Mgkomik.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Mgkomik.kt @@ -12,6 +12,6 @@ internal class Mgkomik(context: MangaLoaderContext) : override val tagPrefix = "genres/" override val listUrl = "komik/" override val datePattern = "dd MMM yy" - override val stylepage = "" + override val stylePage = "" override val sourceLocale: Locale = Locale.ENGLISH } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/it/Beyondtheataraxia.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/it/Beyondtheataraxia.kt index 0e501837b..5f55f35d2 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/it/Beyondtheataraxia.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/it/Beyondtheataraxia.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("BEYONDTHEATARAXIA", "Beyondtheataraxia", "it") +@MangaSourceParser("BEYONDTHEATARAXIA", "Beyond The Ataraxia", "it") internal class Beyondtheataraxia(context: MangaLoaderContext) : MadaraParser(context, MangaSource.BEYONDTHEATARAXIA, "www.beyondtheataraxia.com", 10) { override val datePattern = "d MMMM yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ja/HachiManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ja/HachiManga.kt index 1795b524a..8cad125bf 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ja/HachiManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ja/HachiManga.kt @@ -153,7 +153,7 @@ internal class HachiManga(context: MangaLoaderContext) : MadaraParser(context, M return root2.select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirst("a") val href = a?.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") - val link = href + stylepage + val link = href + stylePage val dateText = li.selectFirst("a.c-new-tag")?.attr("title") ?: li.selectFirst(selectDate)?.text() val name = a.selectFirst("p")?.text() ?: a.ownText() MangaChapter( diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/AkumanoTenshi.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/AkumanoTenshi.kt index dbed2c1a8..2284081b1 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/AkumanoTenshi.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/AkumanoTenshi.kt @@ -11,5 +11,5 @@ internal class AkumanoTenshi(context: MangaLoaderContext) : override val listUrl = "series/" override val tagPrefix = "series-genre/" override val datePattern = "dd/MM/yyyy" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/CafecomYaoi.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/CafecomYaoi.kt index b70f22438..299c5d892 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/CafecomYaoi.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/CafecomYaoi.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class CafecomYaoi(context: MangaLoaderContext) : MadaraParser(context, MangaSource.CAFECOMYAOI, "cafecomyaoi.com.br") { override val datePattern = "dd/MM/yyyy" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Fbsquads.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Fbsquads.kt index b3683264a..6fec4dd16 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Fbsquads.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Fbsquads.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("FBSQUADS", "Fbsquads", "pt", ContentType.HENTAI) +@MangaSourceParser("FBSQUADS", "Fb Squads", "pt", ContentType.HENTAI) internal class Fbsquads(context: MangaLoaderContext) : MadaraParser(context, MangaSource.FBSQUADS, "fbsquads.com") { override val datePattern: String = "dd/MM/yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/LadyestelarScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/LadyestelarScan.kt new file mode 100644 index 000000000..c2943ab91 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/LadyestelarScan.kt @@ -0,0 +1,12 @@ +package org.koitharu.kotatsu.parsers.site.madara.pt + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +import org.koitharu.kotatsu.parsers.MangaSourceParser +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.site.madara.MadaraParser + +@MangaSourceParser("LADYESTELARSCAN", "Lady Estelar Scan", "pt") +internal class LadyestelarScan(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.LADYESTELARSCAN, "ladyestelarscan.com.br", 10) { + override val datePattern: String = "dd/MM/yyyy" +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Leitorizakaya.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Leitorizakaya.kt index 572c2c01d..04554168c 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Leitorizakaya.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Leitorizakaya.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("LEITORIZAKAYA", "Leitorizakaya", "pt", ContentType.HENTAI) +@MangaSourceParser("LEITORIZAKAYA", "Leitor Izakaya", "pt", ContentType.HENTAI) internal class Leitorizakaya(context: MangaLoaderContext) : MadaraParser(context, MangaSource.LEITORIZAKAYA, "leitorizakaya.net") { override val datePattern: String = "dd/MM/yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/LimboScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/LimboScan.kt new file mode 100644 index 000000000..504f30779 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/LimboScan.kt @@ -0,0 +1,14 @@ +package org.koitharu.kotatsu.parsers.site.madara.pt + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +import org.koitharu.kotatsu.parsers.MangaSourceParser +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.site.madara.MadaraParser + +@MangaSourceParser("LIMBOSCAN", "Limbo Scan", "pt") +internal class LimboScan(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.LIMBOSCAN, "limboscan.com.br") { + override val tagPrefix = "obras-genre/" + override val listUrl= "obras/" + override val datePattern: String = "dd/MM/yyyy" +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/PassamaoScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/PassamaoScan.kt new file mode 100644 index 000000000..3150f150a --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/PassamaoScan.kt @@ -0,0 +1,12 @@ +package org.koitharu.kotatsu.parsers.site.madara.pt + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +import org.koitharu.kotatsu.parsers.MangaSourceParser +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.site.madara.MadaraParser + +@MangaSourceParser("PASSAMAOSCAN", "Passamao Scan", "pt") +internal class PassamaoScan(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.PASSAMAOSCAN, "passamaoscan.com") { + override val datePattern: String = "dd/MM/yyyy" +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Pirulitorosa.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Pirulitorosa.kt index c24fa58e2..fc76af6a4 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Pirulitorosa.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Pirulitorosa.kt @@ -6,9 +6,9 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("PIRULITOROSA", "Pirulitorosa", "pt", ContentType.HENTAI) +@MangaSourceParser("PIRULITOROSA", "Pirulito Rosa", "pt", ContentType.HENTAI) internal class Pirulitorosa(context: MangaLoaderContext) : MadaraParser(context, MangaSource.PIRULITOROSA, "pirulitorosa.site") { - override val postreq = true + override val postReq = true override val datePattern: String = "dd/MM/yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/YugenMangas.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/ReMangas.kt similarity index 55% rename from src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/YugenMangas.kt rename to src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/ReMangas.kt index 50abe4628..9c41cdd88 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/YugenMangas.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/ReMangas.kt @@ -5,8 +5,8 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("YUGENMANGAS", "Yugen Mangas", "pt") -internal class YugenMangas(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.YUGENMANGAS, "yugenmangas.com.br", 10) { - override val listUrl = "series/" +@MangaSourceParser("REMANGAS", "Re Mangas", "pt") +internal class ReMangas(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.REMANGAS, "remangas.net") { + override val datePattern = "dd/MM/yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/WickedWitchScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/WickedWitchScan.kt index a1a6e6d18..15419b1ec 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/WickedWitchScan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/WickedWitchScan.kt @@ -5,8 +5,8 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("WICKEDWITCHSCAN", "WickedWitch Scan", "pt") +@MangaSourceParser("WICKEDWITCHSCAN", "Wicked Witch Scan", "pt") internal class WickedWitchScan(context: MangaLoaderContext) : MadaraParser(context, MangaSource.WICKEDWITCHSCAN, "wickedwitchscan.com", pageSize = 10) { - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Ycscan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Ycscan.kt index dce102ab9..1c71579ff 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Ycscan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/Ycscan.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("YCSCAN", "Ycscan", "pt", ContentType.HENTAI) +@MangaSourceParser("YCSCAN", "Yc Scan", "pt", ContentType.HENTAI) internal class Ycscan(context: MangaLoaderContext) : MadaraParser(context, MangaSource.YCSCAN, "ycscan.com", 20) { override val datePattern: String = "dd/MM/yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/ZeroScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/ZeroScan.kt index 2abc235f5..20d5f5618 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/ZeroScan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/ZeroScan.kt @@ -8,6 +8,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("ZEROSCAN", "Zero Scan", "pt") internal class ZeroScan(context: MangaLoaderContext) : MadaraParser(context, MangaSource.ZEROSCAN, "zeroscan.com.br") { - override val postreq = true + override val postReq = true override val datePattern: String = "dd/MM/yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/BestManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/BestManga.kt index b0068f3f5..80bd3f94b 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/BestManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/BestManga.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class BestManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.BEST_MANGA, "bestmanga.club") { override val datePattern = "dd.MM.yyyy" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/MangaMammy.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/MangaMammy.kt index 5e15330c0..444a63c32 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/MangaMammy.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/MangaMammy.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class MangaMammy(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAMAMMY, "mangamammy.ru") { override val datePattern = "dd.MM.yyyy" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/MangaoneLove.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/MangaoneLove.kt index 63eee42b8..55f8ab1af 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/MangaoneLove.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/MangaoneLove.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class MangaoneLove(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAONELOVE, "mangaonelove.site", 10) { override val datePattern = "dd.MM.yyyy" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/th/KingsManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/th/KingsManga.kt index e7a8beb31..21318defe 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/th/KingsManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/th/KingsManga.kt @@ -8,6 +8,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("KINGS_MANGA", "Kings Manga", "th") internal class KingsManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.KINGS_MANGA, "www.kings-manga.co") { - override val postreq = true + override val postReq = true override val datePattern = "d MMMM yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/th/NekoPost.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/th/NekoPost.kt index 68fb70243..5add1e050 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/th/NekoPost.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/th/NekoPost.kt @@ -8,6 +8,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("NEKOPOST", "Neko Post", "th") internal class NekoPost(context: MangaLoaderContext) : MadaraParser(context, MangaSource.NEKOPOST, "www.nekopost.co") { - override val postreq = true + override val postReq = true override val datePattern = "d MMMM yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Anikiga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Anikiga.kt index 24828ecb0..22c930163 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Anikiga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Anikiga.kt @@ -10,5 +10,5 @@ internal class Anikiga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.ANIKIGA, "anikiga.com") { override val tagPrefix = "manga-tur/" override val datePattern = "d MMMM yyyy" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/ArazNovel.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/ArazNovel.kt index 153d72157..2dca9ce40 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/ArazNovel.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/ArazNovel.kt @@ -9,5 +9,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class ArazNovel(context: MangaLoaderContext) : MadaraParser(context, MangaSource.ARAZNOVEL, "araznovel.com", 10) { override val datePattern = "d MMMM yyyy" - override val postreq = true + override val postReq = true } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Cizgiromanarsivi.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Cizgiromanarsivi.kt index a0533b9c7..bd3cff7da 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Cizgiromanarsivi.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Cizgiromanarsivi.kt @@ -8,7 +8,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("CIZGIROMANARSIVI", "Cizgiromanarsivi", "tr") internal class Cizgiromanarsivi(context: MangaLoaderContext) : MadaraParser(context, MangaSource.CIZGIROMANARSIVI, "cizgiromanarsivi.com", 24) { - override val stylepage = "" + override val stylePage = "" override val tagPrefix = "kategori/" override val listUrl = "seri/" override val datePattern = "dd.MM.yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/DomalFansb.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/DomalFansb.kt new file mode 100644 index 000000000..e254c35fc --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/DomalFansb.kt @@ -0,0 +1,13 @@ +package org.koitharu.kotatsu.parsers.site.madara.tr + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +import org.koitharu.kotatsu.parsers.MangaSourceParser +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.site.madara.MadaraParser + +@MangaSourceParser("DOMALFANSB", "Domal Fansub", "tr") +internal class DomalFansb(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.DOMALFANSB, "domalfansb.com") { + override val datePattern = "d MMMM yyyy" + override val tagPrefix = "manga-turleri/" +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/EsoManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/EsoManga.kt index 74dc4348f..6cae564db 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/EsoManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/EsoManga.kt @@ -8,7 +8,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("ESOMANGA", "Eso Manga", "tr") internal class EsoManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.ESOMANGA, "esomanga.com", 10) { - override val postreq = true + override val postReq = true override val datePattern = "dd/MM/yyyy" override val tagPrefix = "manga-kategoriler/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/HoiFansub.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/HoiFansub.kt new file mode 100644 index 000000000..0cea34594 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/HoiFansub.kt @@ -0,0 +1,10 @@ +package org.koitharu.kotatsu.parsers.site.madara.tr + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +import org.koitharu.kotatsu.parsers.MangaSourceParser +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.site.madara.MadaraParser + +@MangaSourceParser("HOIFANSUB", "Hoi Fansub", "tr") +internal class HoiFansub(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.HOIFANSUB, "hoifansub.com", 20) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Jiangzaitoon.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Jiangzaitoon.kt index 985f1fc39..b3c35def7 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Jiangzaitoon.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Jiangzaitoon.kt @@ -6,9 +6,9 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("JIANGZAITOON", "Jiangzaitoon", "tr", ContentType.HENTAI) +@MangaSourceParser("JIANGZAITOON", "Jiangzai Toon", "tr", ContentType.HENTAI) internal class Jiangzaitoon(context: MangaLoaderContext) : MadaraParser(context, MangaSource.JIANGZAITOON, "jiangzaitoon.cc") { - override val postreq = true + override val postReq = true override val datePattern = "d MMMM yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Mangawt.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Mangawt.kt index 5754516e5..9cb51fc31 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Mangawt.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Mangawt.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("MANGAWT", "Mangawt", "tr") +@MangaSourceParser("MANGAWT", "MangaWt", "tr") internal class Mangawt(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAWT, "mangawt.com") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Timenaight.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Timenaight.kt index 30361795f..a2f1cb528 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Timenaight.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Timenaight.kt @@ -5,9 +5,9 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("TIMENAIGHT", "Timenaight", "tr") +@MangaSourceParser("TIMENAIGHT", "Time Naight", "tr") internal class Timenaight(context: MangaLoaderContext) : MadaraParser(context, MangaSource.TIMENAIGHT, "timenaight.com") { - override val postreq = true + override val postReq = true override val datePattern = "dd/MM/yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/TitanManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/TitanManga.kt index 4c0b43376..63aa996af 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/TitanManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/TitanManga.kt @@ -18,7 +18,7 @@ internal class TitanManga(context: MangaLoaderContext) : return doc.select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") val href = a.attrAsRelativeUrl("href") - val link = href + stylepage + val link = href + stylePage val name = a.selectFirst("p")?.text() ?: a.ownText() MangaChapter( id = generateUid(href), diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Webtoonevreni.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Webtoonevreni.kt index 5c390ab95..4aaab8bf0 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Webtoonevreni.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Webtoonevreni.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("WEBTOONEVRENI", "Webtoonevreni", "tr") +@MangaSourceParser("WEBTOONEVRENI", "Webtoon Evreni", "tr") internal class Webtoonevreni(context: MangaLoaderContext) : MadaraParser(context, MangaSource.WEBTOONEVRENI, "webtoonevreni.net", 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Webtoontr.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Webtoontr.kt index 15610dbd4..ae14da579 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Webtoontr.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Webtoontr.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("WEBTOONTR", "Webtoontr", "tr") +@MangaSourceParser("WEBTOONTR", "Webtoon tr", "tr") internal class Webtoontr(context: MangaLoaderContext) : MadaraParser(context, MangaSource.WEBTOONTR, "webtoontr.net", 16) { override val tagPrefix = "webtoon-kategori/" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/vi/HentaiCube.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/vi/HentaiCube.kt index 692c42736..64dde5c10 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/vi/HentaiCube.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/vi/HentaiCube.kt @@ -16,7 +16,7 @@ internal class HentaiCube(context: MangaLoaderContext) : override val datePattern = "dd/MM/yyyy" override val tagPrefix = "the-loai/" - override val postreq = true + override val postReq = true override suspend fun getPages(chapter: MangaChapter): List { val fullUrl = chapter.url.toAbsoluteUrl(domain) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madtheme/MadthemeParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madtheme/MadthemeParser.kt index 39a4ca87c..d25942d16 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madtheme/MadthemeParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madtheme/MadthemeParser.kt @@ -137,7 +137,7 @@ internal abstract class MadthemeParser( val fullUrl = manga.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() - val chaptersDeferred = async { getChapters(manga, doc) } + val chaptersDeferred = async { getChapters(doc) } val desc = doc.selectFirstOrThrow(selectDesc).html() @@ -175,7 +175,7 @@ internal abstract class MadthemeParser( protected open val selectDate = "div .chapter-update" protected open val selectChapter = "ul#chapter-list li" - protected open suspend fun getChapters(manga: Manga, doc: Document): List { + protected open suspend fun getChapters(doc: Document): List { val dateFormat = SimpleDateFormat(datePattern, sourceLocale) return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madtheme/en/MangaBuddy.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madtheme/en/MangaBuddy.kt index a6a134d93..33e1415c1 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madtheme/en/MangaBuddy.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madtheme/en/MangaBuddy.kt @@ -2,9 +2,38 @@ package org.koitharu.kotatsu.parsers.site.madtheme.en import org.koitharu.kotatsu.parsers.MangaLoaderContext import org.koitharu.kotatsu.parsers.MangaSourceParser +import org.koitharu.kotatsu.parsers.model.MangaChapter +import org.koitharu.kotatsu.parsers.model.MangaPage import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madtheme.MadthemeParser +import org.koitharu.kotatsu.parsers.util.domain +import org.koitharu.kotatsu.parsers.util.generateUid +import org.koitharu.kotatsu.parsers.util.parseHtml +import org.koitharu.kotatsu.parsers.util.selectFirstOrThrow +import org.koitharu.kotatsu.parsers.util.toAbsoluteUrl +import java.util.ArrayList @MangaSourceParser("MANGABUDDY", "Manga Buddy", "en") internal class MangaBuddy(context: MangaLoaderContext) : - MadthemeParser(context, MangaSource.MANGABUDDY, "mangabuddy.com") + MadthemeParser(context, MangaSource.MANGABUDDY, "mangabuddy.com") { + + override suspend fun getPages(chapter: MangaChapter): List { + val chapterUrl = chapter.url.toAbsoluteUrl(domain) + val docs = webClient.httpGet(chapterUrl).parseHtml() + val script = docs.selectFirstOrThrow("script:containsData(chapImages)") + val images = script.data().substringAfter("'").substringBeforeLast("'").split(",") + val pages = ArrayList(images.size) + for (image in images) { + pages.add( + MangaPage( + id = generateUid(image), + url = image, + preview = null, + source = source, + ), + ) + } + return pages + + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madtheme/en/Mangaxyz.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madtheme/en/Mangaxyz.kt index c097f52cd..ce84137bc 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madtheme/en/Mangaxyz.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madtheme/en/Mangaxyz.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madtheme.MadthemeParser -@MangaSourceParser("MANGAXYZ", "Mangaxyz", "en") +@MangaSourceParser("MANGAXYZ", "MangaXyz", "en") internal class Mangaxyz(context: MangaLoaderContext) : MadthemeParser(context, MangaSource.MANGAXYZ, "mangaxyz.com") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/manga18/Manga18Parser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/manga18/Manga18Parser.kt index 932c5a483..3b13ab1ca 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/manga18/Manga18Parser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/manga18/Manga18Parser.kt @@ -132,7 +132,7 @@ internal abstract class Manga18Parser( val doc = webClient.httpGet(fullUrl).parseHtml() val body = doc.body().selectFirstOrThrow("div.detail_listInfo") - val chaptersDeferred = async { getChapters(manga, doc) } + val chaptersDeferred = async { getChapters(doc) } val desc = doc.selectFirstOrThrow(selectDesc).html() @@ -167,7 +167,7 @@ internal abstract class Manga18Parser( protected open val selectDate = "div.item p" protected open val selectChapter = "div.chapter_box li" - protected open suspend fun getChapters(manga: Manga, doc: Document): List { + protected open suspend fun getChapters(doc: Document): List { val dateFormat = SimpleDateFormat(datePattern, sourceLocale) return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/manga18/zh/Hanman18.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/manga18/zh/Hanman18.kt index b96bec34f..ad6f9fd90 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/manga18/zh/Hanman18.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/manga18/zh/Hanman18.kt @@ -7,11 +7,11 @@ import org.koitharu.kotatsu.parsers.model.* import org.koitharu.kotatsu.parsers.site.manga18.Manga18Parser import org.koitharu.kotatsu.parsers.util.* -@MangaSourceParser("HANMAN18", "Hanman18", "zh", ContentType.HENTAI) +@MangaSourceParser("HANMAN18", "Hanman 18", "zh", ContentType.HENTAI) internal class Hanman18(context: MangaLoaderContext) : Manga18Parser(context, MangaSource.HANMAN18, "hanman18.com") { - override suspend fun getChapters(manga: Manga, doc: Document): List { + override suspend fun getChapters(doc: Document): List { return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") val href = a.attrAsRelativeUrl("href") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangabox/MangaboxParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangabox/MangaboxParser.kt index 5cfee1d90..0db621e92 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangabox/MangaboxParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangabox/MangaboxParser.kt @@ -130,7 +130,7 @@ internal abstract class MangaboxParser( val fullUrl = manga.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() - val chaptersDeferred = async { getChapters(manga, doc) } + val chaptersDeferred = async { getChapters(doc) } val desc = doc.selectFirstOrThrow(selectDesc).html() @@ -168,7 +168,7 @@ internal abstract class MangaboxParser( protected open val selectDate = "span" protected open val selectChapter = "div.chapter-list div.row, ul.row-content-chapter li" - protected open suspend fun getChapters(manga: Manga, doc: Document): List { + protected open suspend fun getChapters(doc: Document): List { val dateFormat = SimpleDateFormat(datePattern, sourceLocale) return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangabox/en/Mangairo.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangabox/en/Mangairo.kt index 717c0f838..fdeea41f6 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangabox/en/Mangairo.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangabox/en/Mangairo.kt @@ -116,7 +116,7 @@ internal class Mangairo(context: MangaLoaderContext) : val fullUrl = manga.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() - val chaptersDeferred = async { getChapters(manga, doc) } + val chaptersDeferred = async { getChapters(doc) } val desc = doc.selectFirstOrThrow(selectDesc).html() diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangabox/en/Mangakakalot.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangabox/en/Mangakakalot.kt index b4af9d45d..993246547 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangabox/en/Mangakakalot.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangabox/en/Mangakakalot.kt @@ -81,7 +81,7 @@ internal class Mangakakalot(context: MangaLoaderContext) : } } - override suspend fun getChapters(manga: Manga, doc: Document): List { + override suspend fun getChapters(doc: Document): List { return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt index 3e9787522..59f5560be 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt @@ -93,7 +93,6 @@ internal abstract class MangaReaderParser( val relativeUrl = a.attrAsRelativeUrl("href") val rating = it.selectFirst(".numscore")?.text() ?.toFloatOrNull()?.div(10) ?: RATING_UNKNOWN - Manga( id = generateUid(relativeUrl), url = relativeUrl, @@ -132,7 +131,6 @@ internal abstract class MangaReaderParser( } open suspend fun parseInfo(docs: Document, manga: Manga, chapters: List): Manga { - /// set if is table val tableMode = docs.selectFirst("div.seriestucontent > div.seriestucontentr") ?: docs.selectFirst("div.seriestucontentr") @@ -214,6 +212,10 @@ internal abstract class MangaReaderParser( ) } + override suspend fun getRelatedManga(seed: Manga): List { + return parseMangaList(webClient.httpGet(seed.url.toAbsoluteUrl(domain)).parseHtml()) + } + protected open val encodedSrc = false protected open val selectScript = "div.wrapper script" protected open val selectPage = "div#readerarea img" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/Areascans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/Areascans.kt index b99b9182e..1f48852ae 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/Areascans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/Areascans.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("AREASCANS", "Areascans", "ar") +@MangaSourceParser("AREASCANS", "Area Scans", "ar") internal class Areascans(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.AREASCANS, "www.areascans.net", pageSize = 20, searchPageSize = 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/AresManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/AresManga.kt index 5b43fdf09..03ba48b81 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/AresManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/AresManga.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("ARESMANGA", "AresManga", "ar") +@MangaSourceParser("ARESMANGA", "Ares Manga", "ar") internal class AresManga(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.ARESMANGA, "aresnov.org", pageSize = 20, searchPageSize = 10) { override val listUrl = "/series" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/BeastScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/BeastScans.kt index b58b9e1a9..0b7630684 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/BeastScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/BeastScans.kt @@ -7,4 +7,4 @@ import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser @MangaSourceParser("BEASTSCANS", "Beast Scans", "ar") internal class BeastScans(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.BEASTSCANS, "beast-scans.com", pageSize = 20, searchPageSize = 10) + MangaReaderParser(context, MangaSource.BEASTSCANS, "beastscans.net", pageSize = 20, searchPageSize = 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/Mangaatrend.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/Mangaatrend.kt index 10424b561..e36d349c8 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/Mangaatrend.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/Mangaatrend.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("MANGAATREND", "Mangaatrend", "ar") +@MangaSourceParser("MANGAATREND", "Manga A Trend", "ar") internal class Mangaatrend(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.MANGAATREND, "mangaatrend.net", pageSize = 40, searchPageSize = 20) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/Ozulscans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/Ozulscans.kt index 0d0155d14..a48a93f53 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/Ozulscans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/Ozulscans.kt @@ -7,4 +7,4 @@ import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser @MangaSourceParser("OZULSCANS", "Ozul Scans", "ar") internal class Ozulscans(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.OZULSCANS, "ozulscans.net", pageSize = 30, searchPageSize = 30) + MangaReaderParser(context, MangaSource.OZULSCANS, "ar-ozulscans.com", pageSize = 30, searchPageSize = 30) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/ArenaScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/AstraScans.kt similarity index 57% rename from src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/ArenaScans.kt rename to src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/AstraScans.kt index 0da9780fe..06c05b228 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/ArenaScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/AstraScans.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("ARENASCANS", "Team 11x11", "en") -internal class ArenaScans(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.ARENASCANS, "team11x11.com", pageSize = 20, searchPageSize = 10) +@MangaSourceParser("ASTRASCANS", "Astra Scans", "en") +internal class AstraScans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.ASTRASCANS, "astrascans.com", pageSize = 30, searchPageSize = 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/AsuraScansParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/AsuraScansParser.kt index 9d6aaa962..31682c8f6 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/AsuraScansParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/AsuraScansParser.kt @@ -8,6 +8,6 @@ import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser @MangaSourceParser("ASURASCANS", "Asura Scans", "en") internal class AsuraScansParser(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.ASURASCANS, "asuratoon.com", pageSize = 20, searchPageSize = 10) { - override val selectPage = "div#readerarea p img" + override val selectPage = "#readerarea img:not(.asurascans)" override val selectTestScript = "force html" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/FreakComic.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/FreakComic.kt index fbbb4cf50..151f3ebdd 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/FreakComic.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/FreakComic.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("FREAKCOMIC", "FreakComic", "en") +@MangaSourceParser("FREAKCOMIC", "Freak Comic", "en") internal class FreakComic(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.FREAKCOMIC, "freakcomic.com", pageSize = 20, searchPageSize = 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/MagusManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/MagusManga.kt new file mode 100644 index 000000000..ad6a50b9c --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/MagusManga.kt @@ -0,0 +1,10 @@ +package org.koitharu.kotatsu.parsers.site.mangareader.en + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +import org.koitharu.kotatsu.parsers.MangaSourceParser +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser + +@MangaSourceParser("MAGUSMANGA", "Magus Manga", "en") +internal class MagusManga(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MAGUSMANGA, "magusmanga.com", pageSize = 20, searchPageSize = 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/ManhwaLover.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/ManhwaLover.kt index 08fcdd9aa..4b29504dc 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/ManhwaLover.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/ManhwaLover.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("MANHWALOVER", "ManhwaLover", "en", ContentType.HENTAI) +@MangaSourceParser("MANHWALOVER", "Manhwa Lover", "en", ContentType.HENTAI) internal class ManhwaLover(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.MANHWALOVER, "manhwalover.com", pageSize = 20, searchPageSize = 20) { override val datePattern = "MMM d, yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/Manhwax.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/Manhwax.kt index e778b93dd..39cc52449 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/Manhwax.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/Manhwax.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("MANHWAX", "Manhwax", "en", ContentType.HENTAI) +@MangaSourceParser("MANHWAX", "ManhwaX", "en", ContentType.HENTAI) internal class Manhwax(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.MANHWAX, "manhwax.org", pageSize = 20, searchPageSize = 20) { override val datePattern = "MMM d, yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/Manjanoon.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/Manjanoon.kt new file mode 100644 index 000000000..99f77ba73 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/Manjanoon.kt @@ -0,0 +1,10 @@ +package org.koitharu.kotatsu.parsers.site.mangareader.en + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +import org.koitharu.kotatsu.parsers.MangaSourceParser +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser + +@MangaSourceParser("MANJANOON_EN", "Manjanoon", "en") +internal class Manjanoon(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANJANOON_EN, "manjanoon.net", pageSize = 20, searchPageSize = 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/RaiScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/RaiScans.kt new file mode 100644 index 000000000..cc5e59929 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/RaiScans.kt @@ -0,0 +1,12 @@ +package org.koitharu.kotatsu.parsers.site.mangareader.en + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +import org.koitharu.kotatsu.parsers.MangaSourceParser +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser + +@MangaSourceParser("RAISCANS", "Rai Scans", "en") +internal class RaiScans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.RAISCANS, "www.raiscans.com", pageSize = 20, searchPageSize = 10) { + override val listUrl = "/Series" +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/RealmScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/RealmScans.kt index 22513d2ac..94d5dcff3 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/RealmScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/RealmScans.kt @@ -16,7 +16,7 @@ import org.koitharu.kotatsu.parsers.util.oneOrThrowIfMany import org.koitharu.kotatsu.parsers.util.parseHtml import java.util.EnumSet -@MangaSourceParser("REALMSCANS", "RealmScans", "en") +@MangaSourceParser("REALMSCANS", "Realm Scans", "en") internal class RealmScans(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.REALMSCANS, "realmscans.to", pageSize = 52, searchPageSize = 50) { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/AiyuMangaScanlation.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/AiyuMangaScanlation.kt new file mode 100644 index 000000000..bf5889734 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/AiyuMangaScanlation.kt @@ -0,0 +1,10 @@ +package org.koitharu.kotatsu.parsers.site.mangareader.es + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +import org.koitharu.kotatsu.parsers.MangaSourceParser +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser + +@MangaSourceParser("AIYUMANGASCANLATION", "Aiyu Manhua", "es") +internal class AiyuMangaScanlation(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.AIYUMANGASCANLATION, "aiyumanhua.com", 20, 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/Raikiscan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/Raikiscan.kt index 38d3b1e6f..c9c3823e6 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/Raikiscan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/Raikiscan.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("RAIKISCAN", "Raikiscan", "es") +@MangaSourceParser("RAIKISCAN", "Raiki Scan", "es") internal class Raikiscan(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.RAIKISCAN, "raikiscan.com", pageSize = 20, searchPageSize = 20) { override val datePattern = "MMM d, yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/Senpaiediciones.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/Senpaiediciones.kt index 4cc1e8e94..8ddc38c50 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/Senpaiediciones.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/Senpaiediciones.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("SENPAIEDICIONES", "Senpaiediciones", "es") +@MangaSourceParser("SENPAIEDICIONES", "Senpai Ediciones", "es") internal class Senpaiediciones(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.SENPAIEDICIONES, "senpaiediciones.com", pageSize = 20, searchPageSize = 20) { override val datePattern = "MMM d, yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/Shadowmangas.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/Shadowmangas.kt index 239bba880..2ebbad02c 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/Shadowmangas.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/es/Shadowmangas.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("SHADOWMANGAS", "Shadowmangas", "es") +@MangaSourceParser("SHADOWMANGAS", "Shadow Mangas", "es") internal class Shadowmangas(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.SHADOWMANGAS, "shadowmangas.com", pageSize = 10, searchPageSize = 10) { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/EpsilonscanParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/EpsilonscanParser.kt index 51124f384..74dd267c2 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/EpsilonscanParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/EpsilonscanParser.kt @@ -6,6 +6,6 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("EPSILONSCAN", "Epsilonscan", "fr", ContentType.HENTAI) +@MangaSourceParser("EPSILONSCAN", "Epsilon Scan", "fr", ContentType.HENTAI) internal class EpsilonscanParser(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.EPSILONSCAN, "epsilonscan.fr", pageSize = 20, searchPageSize = 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/LelManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/LelManga.kt index 0512380c2..b9ecf1fc0 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/LelManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/LelManga.kt @@ -7,11 +7,14 @@ import org.koitharu.kotatsu.parsers.model.MangaPage import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser import org.koitharu.kotatsu.parsers.util.* +import java.util.Locale @MangaSourceParser("LELMANGA", "Lel Manga", "fr") internal class LelManga(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.LELMANGA, "www.lelmanga.com", pageSize = 21, searchPageSize = 20) { + override val sourceLocale: Locale = Locale.ENGLISH + override suspend fun getPages(chapter: MangaChapter): List { val fullUrl = chapter.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/PhenixscansParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/PhenixscansParser.kt index fb8ece3b3..9e7447390 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/PhenixscansParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/PhenixscansParser.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("PHENIXSCANS", "Phenixscans", "fr") +@MangaSourceParser("PHENIXSCANS", "Phenix Scans", "fr") internal class PhenixscansParser(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.PHENIXSCANS, "phenixscans.fr", pageSize = 20, searchPageSize = 10) { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/Duniakomik.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/Duniakomik.kt index 5049e43d8..26cfcffbf 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/Duniakomik.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/Duniakomik.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("DUNIAKOMIK", "Duniakomik", "id", ContentType.HENTAI) +@MangaSourceParser("DUNIAKOMIK", "Dunia Komik", "id", ContentType.HENTAI) internal class Duniakomik(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.DUNIAKOMIK, "duniakomik.org", pageSize = 12, searchPageSize = 12) { override val datePattern = "MMM d, yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/Komikcast.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/Komikcast.kt index 171135876..584ecf67a 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/Komikcast.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/Komikcast.kt @@ -18,6 +18,8 @@ internal class Komikcast(context: MangaLoaderContext) : override val listUrl = "/daftar-komik" override val datePattern = "MMM d, yyyy" override val sourceLocale: Locale = Locale.ENGLISH + override val sortOrders: Set + get() = EnumSet.of(SortOrder.UPDATED, SortOrder.POPULARITY, SortOrder.ALPHABETICAL) override suspend fun getListPage( page: Int, @@ -29,7 +31,6 @@ internal class Komikcast(context: MangaLoaderContext) : if (page > lastSearchPage) { return emptyList() } - val url = buildString { append("https://") append(domain) @@ -38,21 +39,12 @@ internal class Komikcast(context: MangaLoaderContext) : append("/?s=") append(query.urlEncoded()) } - val docs = webClient.httpGet(url).parseHtml() lastSearchPage = docs.selectFirst(".pagination .next") ?.previousElementSibling() ?.text()?.toIntOrNull() ?: 1 return parseMangaList(docs) } - - val sortQuery = when (sortOrder) { - SortOrder.ALPHABETICAL -> "title" - SortOrder.NEWEST -> "latest" - SortOrder.POPULARITY -> "popular" - SortOrder.UPDATED -> "update" - else -> "" - } val tagKey = "genre[]".urlEncoded() val tagQuery = if (tags.isNullOrEmpty()) "" else tags.joinToString(separator = "&", prefix = "&") { "$tagKey=${it.key}" } @@ -62,11 +54,14 @@ internal class Komikcast(context: MangaLoaderContext) : append(listUrl) append("/page/") append(page) - append("/?orderby=") - append(sortQuery) + when (sortOrder) { + SortOrder.ALPHABETICAL -> append("/?orderby=titleasc") + SortOrder.POPULARITY -> append("/?orderby=popular") + SortOrder.UPDATED -> append("/?sortby=update") + else -> append("/?sortby=update") + } append(tagQuery) } - return parseMangaList(webClient.httpGet(url).parseHtml()) } @@ -93,24 +88,15 @@ internal class Komikcast(context: MangaLoaderContext) : } override suspend fun parseInfo(docs: Document, manga: Manga, chapters: List): Manga { - // / set if is table - val tagMap = getOrCreateTagMap() - val tags = docs.select(".komik_info-content-genre > a").mapNotNullToSet { tagMap[it.text()] } - - val state = docs.selectFirst(".komik_info-content-meta span:contains(Status)")?.lastElementChild() - - val mangaState = state?.let { - when (it.text()) { - "Ongoing" -> MangaState.ONGOING - "Completed" -> MangaState.FINISHED - else -> null - } + val state = docs.selectFirst(".komik_info-content-meta span:contains(Status)")?.html() + val mangaState = if (state!!.contains("Ongoing")) { + MangaState.ONGOING + } else { + MangaState.FINISHED } - val author = docs.selectFirst(".komik_info-content-meta span:contains(Author)")?.lastElementChild()?.text() - val nsfw = docs.selectFirst(".restrictcontainer") != null || docs.selectFirst(".info-right .alr") != null || docs.selectFirst( ".postbody .alr", @@ -131,7 +117,6 @@ internal class Komikcast(context: MangaLoaderContext) : val a = it.selectFirstOrThrow("a.data-tooltip") val relativeUrl = a.attrAsRelativeUrl("href") val rating = it.selectFirst(".numscore")?.text()?.toFloatOrNull()?.div(10) ?: RATING_UNKNOWN - val name = it.selectFirst("h3.title")?.text().orEmpty() Manga( id = generateUid(relativeUrl), @@ -153,7 +138,6 @@ internal class Komikcast(context: MangaLoaderContext) : override suspend fun getPages(chapter: MangaChapter): List { val chapterUrl = chapter.url.toAbsoluteUrl(domain) val docs = webClient.httpGet(chapterUrl).parseHtml() - val test = docs.select("script:containsData(ts_reader)") if (test.isNullOrEmpty()) { return docs.select("div#chapter_body img").map { img -> @@ -180,7 +164,6 @@ internal class Komikcast(context: MangaLoaderContext) : ), ) } - return pages } } @@ -199,7 +182,6 @@ internal class Komikcast(context: MangaLoaderContext) : private fun parseRelativeDate(date: String): Long { val number = Regex("""(\d+)""").find(date)?.value?.toIntOrNull() ?: return 0 val cal = Calendar.getInstance() - return when { WordSet( "day", diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/KomiklokalCfd.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/KomiklokalCfd.kt index 09c7bb3ba..8f8dcbed5 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/KomiklokalCfd.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/KomiklokalCfd.kt @@ -7,8 +7,8 @@ import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser import java.util.* -@MangaSourceParser("KOMIKLOKALCFD", "Komiklokal .Cfd", "id", ContentType.HENTAI) +@MangaSourceParser("KOMIKLOKALCFD", "Komik Lokal .Sbs", "id", ContentType.HENTAI) internal class KomiklokalCfd(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.KOMIKLOKALCFD, "komiklokal.cfd", pageSize = 30, searchPageSize = 10) { + MangaReaderParser(context, MangaSource.KOMIKLOKALCFD, "komiklokal.sbs", pageSize = 30, searchPageSize = 10) { override val sourceLocale: Locale = Locale.ENGLISH } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/Lianscans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/Lianscans.kt index 8a6bbc1a8..b3f6c1c9f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/Lianscans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/Lianscans.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("LIANSCANS", "Lianscans", "id", ContentType.HENTAI) +@MangaSourceParser("LIANSCANS", "Lian Scans", "id", ContentType.HENTAI) internal class Lianscans(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.LIANSCANS, "www.lianscans.my.id", pageSize = 10, searchPageSize = 10) { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/MiraiScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/MiraiScans.kt new file mode 100644 index 000000000..6bcd86e8e --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/MiraiScans.kt @@ -0,0 +1,14 @@ +package org.koitharu.kotatsu.parsers.site.mangareader.id + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +import org.koitharu.kotatsu.parsers.MangaSourceParser +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser +import java.util.Locale + +@MangaSourceParser("MIRAISCANS", "Mirai Scans", "id") +internal class MiraiScans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MIRAISCANS, "miraiscans.com", pageSize = 20, searchPageSize = 10) { + override val sourceLocale: Locale = Locale.ENGLISH + override val listUrl = "/komik" +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pl/SkanlacjeFeniksy.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pl/SkanlacjeFeniksy.kt index 8203ffe0d..3c2dff68a 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pl/SkanlacjeFeniksy.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pl/SkanlacjeFeniksy.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("SKANLACJEFENIKSY", "SkanlacjeFeniksy", "pl") +@MangaSourceParser("SKANLACJEFENIKSY", "Skanlacje Feniksy", "pl") internal class SkanlacjeFeniksy(context: MangaLoaderContext) : MangaReaderParser( context, diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pt/HentaiSsssscanlator.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pt/HentaiSsssscanlator.kt index 215464fe6..377d568fb 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pt/HentaiSsssscanlator.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pt/HentaiSsssscanlator.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("HENTAISSSSSCANLATOR", "Sssscanlator Hentai", "pt", type = ContentType.HENTAI) +@MangaSourceParser("HENTAISSSSSCANLATOR", "Sss Scanlator Hentai", "pt", type = ContentType.HENTAI) internal class HentaiSsssscanlator(context: MangaLoaderContext) : MangaReaderParser( context, diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pt/Mundomangakun.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pt/Mundomangakun.kt index 8fcbdcb3a..5e03a0e57 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pt/Mundomangakun.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pt/Mundomangakun.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("MUNDOMANGAKUN", "Mundomangakun", "pt") +@MangaSourceParser("MUNDOMANGAKUN", "Mundo Manga Kun", "pt") internal class Mundomangakun(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.MUNDOMANGAKUN, "mundomangakun.com.br", pageSize = 20, searchPageSize = 20) { override val datePattern = "MMM d, yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Ayatoon.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Ayatoon.kt index 089a2c6de..36ec7592d 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Ayatoon.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Ayatoon.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("AYATOON", "Ayatoon", "tr") +@MangaSourceParser("AYATOON", "Aya Toon", "tr") internal class Ayatoon(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.AYATOON, "ayatoon.com", pageSize = 20, searchPageSize = 20) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Golgebahcesi.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Golgebahcesi.kt index fe92337e5..e7370c942 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Golgebahcesi.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Golgebahcesi.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("GOLGEBAHCESI", "Golgebahcesi", "tr") +@MangaSourceParser("GOLGEBAHCESI", "Golge Bahcesi", "tr") internal class Golgebahcesi(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.GOLGEBAHCESI, "golgebahcesi.com", pageSize = 14, searchPageSize = 9) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Mangaefendisi.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Mangaefendisi.kt index fedb44528..c9d752614 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Mangaefendisi.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Mangaefendisi.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("MANGAEFENDISI", "Mangaefendisi", "tr") +@MangaSourceParser("MANGAEFENDISI", "Manga Efendisi", "tr") internal class Mangaefendisi(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.MANGAEFENDISI, "mangaefendisi.net", pageSize = 30, searchPageSize = 20) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Mangaokutr.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Mangaokutr.kt index e20c83ba4..1e1f496be 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Mangaokutr.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Mangaokutr.kt @@ -5,6 +5,6 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("MANGAOKUTR", "Mangaokutr", "tr") +@MangaSourceParser("MANGAOKUTR", "Manga Oku Tr", "tr") internal class Mangaokutr(context: MangaLoaderContext) : MangaReaderParser(context, MangaSource.MANGAOKUTR, "mangaokutr.com", pageSize = 25, searchPageSize = 20) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Raindropteamfan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Raindropteamfan.kt index 8b24bcd6e..555c9816a 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Raindropteamfan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/tr/Raindropteamfan.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser -@MangaSourceParser("RAINDROPTEAMFAN", "Raindropteamfan", "tr") +@MangaSourceParser("RAINDROPTEAMFAN", "Raindrop Fansub", "tr") internal class Raindropteamfan(context: MangaLoaderContext) : MangaReaderParser( context, diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/MmrcmsParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/MmrcmsParser.kt index 193a04e0c..0b934b708 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/MmrcmsParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/MmrcmsParser.kt @@ -22,21 +22,19 @@ internal abstract class MmrcmsParser( override val sortOrders: Set = EnumSet.of( SortOrder.POPULARITY, - SortOrder.ALPHABETICAL, SortOrder.UPDATED, + SortOrder.ALPHABETICAL, ) protected open val listUrl = "filterList" protected open val tagUrl = "manga-list" protected open val datePattern = "dd MMM. yyyy" - init { paginator.firstPage = 1 searchPaginator.firstPage = 1 } - @JvmField protected val ongoing: Set = hashSetOf( "On Going", @@ -66,15 +64,7 @@ internal abstract class MmrcmsParser( sortOrder: SortOrder, ): List { val tag = tags.oneOrThrowIfMany() - val url = if (sortOrder == SortOrder.UPDATED) { - buildString { - append("https://") - append(domain) - append("/latest-release") - append("?page=") - append(page.toString()) - } - } else { + val url = if (!query.isNullOrEmpty() || !tags.isNullOrEmpty() || sortOrder != SortOrder.UPDATED) { buildString { append("https://") append(domain) @@ -83,40 +73,41 @@ internal abstract class MmrcmsParser( append(page.toString()) append("&asc=true&author=&tag=") append("&alpha=") - if (!query.isNullOrEmpty()) { append(query.urlEncoded()) } - append("&cat=") if (!tags.isNullOrEmpty()) { append(tag?.key.orEmpty()) } - append("&sortBy=") when (sortOrder) { SortOrder.POPULARITY -> append("views") SortOrder.ALPHABETICAL -> append("name") - else -> append("views") + else -> append("name") } } + } else { + buildString { + append("https://") + append(domain) + append("/latest-release") + append("?page=") + append(page.toString()) + } } - val doc = webClient.httpGet(url).parseHtml() - - if (sortOrder == SortOrder.UPDATED) { - - return doc.select("div.manga-item").map { div -> + if (!query.isNullOrEmpty() || !tags.isNullOrEmpty() || sortOrder != SortOrder.UPDATED) { + return doc.select("div.media").map { div -> val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href") - val deeplink = href.substringAfterLast("/") Manga( id = generateUid(href), url = href, publicUrl = href.toAbsoluteUrl(div.host ?: domain), - coverUrl = "https://$domain/uploads/manga/$deeplink$imgUpdated", - title = div.selectFirstOrThrow("h3 a").text().orEmpty(), + coverUrl = div.selectFirst("img")?.src().orEmpty(), + title = div.selectFirstOrThrow("div.media-body h5").text().orEmpty(), altTitle = null, - rating = RATING_UNKNOWN, + rating = div.selectFirstOrThrow("span").ownText().toFloatOrNull()?.div(5f) ?: RATING_UNKNOWN, tags = emptySet(), author = null, state = null, @@ -125,16 +116,17 @@ internal abstract class MmrcmsParser( ) } } else { - return doc.select("div.media").map { div -> + return doc.select("div.manga-item").map { div -> val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href") + val deeplink = href.substringAfterLast("/") Manga( id = generateUid(href), url = href, publicUrl = href.toAbsoluteUrl(div.host ?: domain), - coverUrl = div.selectFirst("img")?.src().orEmpty(), - title = div.selectFirstOrThrow("div.media-body h5").text().orEmpty(), + coverUrl = "https://$domain/uploads/manga/$deeplink$imgUpdated", + title = div.selectFirstOrThrow("h3 a").text().orEmpty(), altTitle = null, - rating = div.selectFirstOrThrow("span").ownText().toFloatOrNull()?.div(5f) ?: RATING_UNKNOWN, + rating = RATING_UNKNOWN, tags = emptySet(), author = null, state = null, @@ -169,13 +161,9 @@ internal abstract class MmrcmsParser( val fullUrl = manga.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() val body = doc.body().selectFirstOrThrow("dl.dl-horizontal") - - val chaptersDeferred = async { getChapters(manga, doc) } - + val chaptersDeferred = async { getChapters(doc) } val desc = doc.selectFirstOrThrow(selectDesc).text() - val stateDiv = body.selectFirst(selectState)?.nextElementSibling() - val state = stateDiv?.let { when (it.text()) { in ongoing -> MangaState.ONGOING @@ -183,12 +171,9 @@ internal abstract class MmrcmsParser( else -> null } } - val alt = doc.body().selectFirst(selectAlt)?.nextElementSibling()?.text() val auth = doc.body().selectFirst(selectAut)?.nextElementSibling()?.text() - val tags = doc.body().selectFirst(selectTag)?.nextElementSibling()?.select("a") ?: emptySet() - manga.copy( tags = tags.mapNotNullToSet { a -> MangaTag( @@ -209,9 +194,8 @@ internal abstract class MmrcmsParser( protected open val selectDate = "div.date-chapter-title-rtl" protected open val selectChapter = "ul.chapters > li:not(.btn)" - protected open suspend fun getChapters(manga: Manga, doc: Document): List { + protected open suspend fun getChapters(doc: Document): List { val dateFormat = SimpleDateFormat(datePattern, sourceLocale) - return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") val href = a.attrAsRelativeUrl("href") @@ -234,8 +218,6 @@ internal abstract class MmrcmsParser( override suspend fun getPages(chapter: MangaChapter): List { val fullUrl = chapter.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() - - return doc.select(selectPage).map { url -> val img = url.src()?.toRelativeUrl(domain) ?: url.parseFailed("Image src not found") MangaPage( diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/ar/Onma.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/ar/Onma.kt index c54c38052..5101e05a5 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/ar/Onma.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/ar/Onma.kt @@ -103,7 +103,7 @@ internal class Onma(context: MangaLoaderContext) : val fullUrl = manga.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() val body = doc.body().selectFirstOrThrow("div.panel-body") - val chaptersDeferred = async { getChapters(manga, doc) } + val chaptersDeferred = async { getChapters(doc) } val desc = doc.selectFirst(selectDesc)?.text().orEmpty() val stateDiv = body.selectFirst(selectState) val state = stateDiv?.let { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/JpMangas.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/JpMangas.kt index fda3469df..28be22bc4 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/JpMangas.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/JpMangas.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mmrcms.MmrcmsParser import java.util.* -@MangaSourceParser("JPMANGAS", "JpMangas", "fr") +@MangaSourceParser("JPMANGAS", "Jp Mangas", "fr") internal class JpMangas(context: MangaLoaderContext) : MmrcmsParser(context, MangaSource.JPMANGAS, "jpmangas.xyz") { override val sourceLocale: Locale = Locale.ENGLISH diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/JpScanVf.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/JpScanVf.kt index b52613436..586257efd 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/JpScanVf.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/JpScanVf.kt @@ -7,7 +7,7 @@ import org.koitharu.kotatsu.parsers.site.mmrcms.MmrcmsParser import java.util.* //the search doesn't work on the source. -@MangaSourceParser("JPSCANVF", "JpScanVf", "fr") +@MangaSourceParser("JPSCANVF", "Jp Scan Vf", "fr") internal class JpScanVf(context: MangaLoaderContext) : MmrcmsParser(context, MangaSource.JPSCANVF, "jpscan-vf.net") { override val sourceLocale: Locale = Locale.ENGLISH diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/MangaFr.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/MangaFr.kt index 1bb6f54d0..b4a10f4a6 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/MangaFr.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/MangaFr.kt @@ -8,7 +8,7 @@ import java.util.Locale @MangaSourceParser("MANGAFR", "Manga Fr", "fr") internal class MangaFr(context: MangaLoaderContext) : - MmrcmsParser(context, MangaSource.MANGAFR, "manga-fr.me") { + MmrcmsParser(context, MangaSource.MANGAFR, "manga-fr.cc") { override val imgUpdated = ".jpg" override val sourceLocale: Locale = Locale.ENGLISH } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/MangaScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/MangaScan.kt index a6377be99..ee3f5747a 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/MangaScan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/MangaScan.kt @@ -6,9 +6,9 @@ import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.mmrcms.MmrcmsParser import java.util.Locale -@MangaSourceParser("MANGA_SCAN", "Manga-Scan", "fr") +@MangaSourceParser("MANGA_SCAN", "Manga Scan", "fr") internal class MangaScan(context: MangaLoaderContext) : - MmrcmsParser(context, MangaSource.MANGA_SCAN, "manga-scan.co") { + MmrcmsParser(context, MangaSource.MANGA_SCAN, "manga-scan.me") { override val imgUpdated = ".jpg" override val sourceLocale: Locale = Locale.ENGLISH } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/id/Mangaid.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/id/Mangaid.kt index a72541cab..5ac6b0b2d 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/id/Mangaid.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/id/Mangaid.kt @@ -8,7 +8,7 @@ import org.koitharu.kotatsu.parsers.site.mmrcms.MmrcmsParser import java.util.Locale -@MangaSourceParser("MANGAID", "Mangaid", "id") +@MangaSourceParser("MANGAID", "Manga Id", "id") internal class Mangaid(context: MangaLoaderContext) : MmrcmsParser(context, MangaSource.MANGAID, "mangaid.click") { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/pt/Animaregia.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/pt/Animaregia.kt index 8132c9707..82434a9f3 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/pt/Animaregia.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/pt/Animaregia.kt @@ -31,7 +31,7 @@ internal class Animaregia(context: MangaLoaderContext) : val fullUrl = manga.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() val body = doc.body().selectFirstOrThrow("ul.list-group") - val chaptersDeferred = async { getChapters(manga, doc) } + val chaptersDeferred = async { getChapters(doc) } val desc = doc.select(selectDesc).text() val stateDiv = body.selectFirst("li.list-group-item:contains(Status)")?.lastElementChild() val state = stateDiv?.let { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/otakusanctuary/OtakuSanctuaryParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/otakusanctuary/OtakuSanctuaryParser.kt index 187346989..04c2fc5ae 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/otakusanctuary/OtakuSanctuaryParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/otakusanctuary/OtakuSanctuaryParser.kt @@ -206,7 +206,6 @@ internal abstract class OtakuSanctuaryParser( val urls = json.replace("\\u0022", "").substringAfter("{\"view\":\"[").substringBefore("]\",\"isSuccess") .split(",") return urls.map { - val urlImage = processUrl(it) MangaPage( id = generateUid(urlImage), @@ -290,6 +289,7 @@ internal abstract class OtakuSanctuaryParser( } + @Suppress("NAME_SHADOWING") private fun processUrl(url: String, vi: String = ""): String { var url = url.replace("_h_", "http") .replace("_e_", "/extendContent/Manga") @@ -312,11 +312,11 @@ internal abstract class OtakuSanctuaryParser( } "[IS1]" -> { - val url = url.replace("[IS1]", "https://imagepi.otakuscan.net/") - if (url.contains("vi") && url.contains("otakusan.net_")) { - url + val url1 = url.replace("[IS1]", "https://imagepi.otakuscan.net/") + if (url1.contains("vi") && url1.contains("otakusan.net_")) { + url1 } else { - url.toHttpUrl().newBuilder().apply { + url1.toHttpUrl().newBuilder().apply { addQueryParameter("vi", vi) }.build().toString() } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/BrMangas.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/BrMangas.kt index a894c0f57..592b398cc 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/BrMangas.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/BrMangas.kt @@ -10,7 +10,7 @@ import org.koitharu.kotatsu.parsers.network.UserAgents import org.koitharu.kotatsu.parsers.util.* import java.util.* -@MangaSourceParser("BRMANGAS", "BrMangas", "pt") +@MangaSourceParser("BRMANGAS", "Br Mangas", "pt") internal class BrMangas(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.BRMANGAS, 25) { override val sortOrders: Set = EnumSet.of(SortOrder.POPULARITY, SortOrder.UPDATED) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/GoldenManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/GoldenManga.kt deleted file mode 100644 index 7badc5bb5..000000000 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/GoldenManga.kt +++ /dev/null @@ -1,139 +0,0 @@ -package org.koitharu.kotatsu.parsers.site.pt - -import okhttp3.Headers -import org.koitharu.kotatsu.parsers.MangaLoaderContext -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 java.text.SimpleDateFormat -import java.util.* - -@MangaSourceParser("GOLDENMANGA", "Golden Manga", "pt") -internal class GoldenManga(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.GOLDENMANGA, 36) { - - override val sortOrders: Set = EnumSet.of(SortOrder.ALPHABETICAL) - override val configKeyDomain = ConfigKey.Domain("goldenmanga.top") - override val headers: Headers = Headers.Builder() - .add("User-Agent", UserAgents.CHROME_MOBILE) - .build() - - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val url = buildString { - append("https://") - append(domain) - if (!query.isNullOrEmpty()) { - append("/mangabr?pagina=") - append(page.toString()) - append("&busca=") - append(query.urlEncoded()) - } else { - append("/mangas") - append("?pagina=") - append(page.toString()) - } - if (!tags.isNullOrEmpty()) { - append("&genero=") - for (tag in tags) { - append(tag.key) - append(",") - } - } - } - val doc = webClient.httpGet(url).parseHtml() - return doc.select("section.row div.mangas") - .map { div -> - val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href") - Manga( - id = generateUid(href), - title = div.selectFirstOrThrow("a h3").text(), - altTitle = null, - url = href, - publicUrl = href.toAbsoluteUrl(domain), - rating = RATING_UNKNOWN, - isNsfw = div.selectFirst("div.MangaAdulto") != null, - coverUrl = div.selectFirstOrThrow("img").attrAsAbsoluteUrl("src"), - tags = setOf(), - state = null, - author = null, - source = source, - ) - } - } - - override suspend fun getTags(): Set { - val doc = webClient.httpGet("https://$domain/mangas").parseHtml() - return doc.select("div.container a.btn.btn-warning ").mapNotNullToSet { a -> - MangaTag( - key = a.attr("href").substringAfterLast("="), - title = a.text(), - source = source, - ) - } - } - - override suspend fun getDetails(manga: Manga): Manga { - val root = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() - val dateFormat = SimpleDateFormat("(dd/MM/yyyy)", Locale.ENGLISH) - return manga.copy( - altTitle = null, - state = when (root.select("h5.cg_color")[3].select("a").text()) { - "ativo", "Ativo" -> MangaState.ONGOING - "Completo" -> MangaState.FINISHED - else -> null - }, - tags = root.select("h5.cg_color")[0].select("a").mapNotNullToSet { a -> - - if (a.text().isNullOrEmpty()) { - return@mapNotNullToSet null - } else { - MangaTag( - key = a.attr("href").substringAfterLast("="), - title = a.text().toTitleCase(), - source = source, - ) - } - }, - author = root.select("h5.cg_color a")[1].text(), - description = root.getElementById("manga_capitulo_descricao")?.html(), - chapters = root.requireElementById("capitulos").select("li") - .mapChapters(reversed = true) { i, div -> - val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href") - val dateText = div.selectFirstOrThrow("div.col-sm-5 span").text() - val name = div.selectFirstOrThrow("div.col-sm-5").text().substringBeforeLast("(") - MangaChapter( - id = generateUid(href), - name = name, - number = i, - url = href, - scanlator = null, - uploadDate = dateFormat.tryParse(dateText), - branch = null, - source = source, - ) - }, - ) - } - - override suspend fun getPages(chapter: MangaChapter): List { - val fullUrl = chapter.url.toAbsoluteUrl(domain) - val doc = webClient.httpGet(fullUrl).parseHtml() - val root = doc.body().requireElementById("capitulos_images") - return root.select("img").map { img -> - val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found") - MangaPage( - id = generateUid(url), - url = url, - preview = null, - source = source, - ) - } - } -} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/LerMangaOnline.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/LerMangaOnline.kt new file mode 100644 index 000000000..e3351de94 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/LerMangaOnline.kt @@ -0,0 +1,128 @@ +package org.koitharu.kotatsu.parsers.site.pt + +import org.jsoup.nodes.Document +import org.koitharu.kotatsu.parsers.MangaLoaderContext +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.util.* +import java.lang.IllegalArgumentException +import java.text.SimpleDateFormat +import java.util.* + +@MangaSourceParser("LERMANGAONLINE", "Ler Manga Online", "pt") +class LerMangaOnline(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.LERMANGAONLINE, 20) { + + override val sortOrders: Set = EnumSet.of(SortOrder.UPDATED) + + override val configKeyDomain = ConfigKey.Domain("lermangaonline.com.br") + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + if (!query.isNullOrEmpty()) { + throw IllegalArgumentException("Search is not supported by this source") + } + val tag = tags.oneOrThrowIfMany() + val url = buildString { + append("https://") + append(domain) + append("/") + if (!tags.isNullOrEmpty()) { + append(tag?.key.orEmpty()) + append("/") + } + if (page > 1) { + append("page/") + append(page) + append("/") + } + } + return parseManga(webClient.httpGet(url).parseHtml()) + } + + private fun parseManga(docs: Document): List { + return docs.select(".materias .article").map { div -> + val a = div.selectFirstOrThrow("a") + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = a.attrAsAbsoluteUrl("href"), + title = div.selectLastOrThrow("section h3").text(), + coverUrl = div.selectFirst("img")?.src().orEmpty(), + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + description = null, + state = null, + author = null, + isNsfw = isNsfwSource, + source = source, + ) + } + } + + override suspend fun getTags(): Set { + val doc = webClient.httpGet("https://$domain/").parseHtml().requireElementById("sub-menu") + return doc.select("ul.container li a").mapNotNullToSet { a -> + MangaTag( + key = a.attr("href").removePrefix("/"), + title = a.text(), + source = source, + ) + } + } + + override suspend fun getDetails(manga: Manga): Manga { + val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() + val dateFormat = SimpleDateFormat("dd-MM-yyyy", Locale.ROOT) + return manga.copy( + description = doc.selectFirst(".sinopse")?.html(), + tags = doc.selectFirst(".categorias-blog")?.select("a")?.mapNotNullToSet { a -> + MangaTag( + key = a.attr("href").removePrefix("/"), + title = a.text().ifEmpty { return@mapNotNullToSet null }.toTitleCase(), + source = source, + ) + }.orEmpty(), + chapters = doc.select(".capitulos a").mapChapters(reversed = true) { i, a -> + val href = a.attrAsRelativeUrl("href") + val title = a.selectFirstOrThrow(".capitulo").html().substringBeforeLast(" { + return parseManga(webClient.httpGet(seed.url.toAbsoluteUrl(domain)).parseHtml()) + } + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + return doc.select(".images img").map { img -> + val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found") + MangaPage( + id = generateUid(url), + url = url, + preview = null, + source = source, + ) + } + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/MangaOnline.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/MangaOnline.kt new file mode 100644 index 000000000..bc91d3ae2 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/MangaOnline.kt @@ -0,0 +1,152 @@ +package org.koitharu.kotatsu.parsers.site.pt + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +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.util.* +import java.text.SimpleDateFormat +import java.util.* + +@MangaSourceParser("MANGAONLINE", "Manga Online", "pt") +class MangaOnline(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.MANGAONLINE, 20) { + + override val sortOrders: Set = EnumSet.of(SortOrder.UPDATED) + + override val configKeyDomain = ConfigKey.Domain("mangaonline.biz") + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + val tag = tags.oneOrThrowIfMany() + val url = buildString { + append("https://") + append(domain) + when { + !tags.isNullOrEmpty() -> { + append("/genero/") + append(tag?.key.orEmpty()) + append("/") + } + + !query.isNullOrEmpty() -> { + append("/search/") + append(query.urlEncoded()) + append("/") + } + + else -> { + append("/manga/") + } + } + if (page > 1) { + append("page/") + append(page) + append("/") + } + } + val doc = webClient.httpGet(url).parseHtml() + return doc.select(".items .item, .items2 .item").map { div -> + val a = div.selectFirstOrThrow("a") + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = a.attrAsAbsoluteUrl("href"), + title = div.selectLastOrThrow(".data h3").text(), + coverUrl = div.selectFirst("img")?.src().orEmpty(), + altTitle = null, + rating = div.selectFirst(".rating")?.ownText()?.toFloatOrNull()?.div(10f) ?: RATING_UNKNOWN, + tags = emptySet(), + description = null, + state = null, + author = null, + isNsfw = isNsfwSource, + source = source, + ) + } + } + + override suspend fun getTags(): Set { + val doc = webClient.httpGet("https://$domain/generos/").parseHtml() + return doc.select(".wp-content p a").mapNotNullToSet { a -> + MangaTag( + key = a.attr("href").removeSuffix("/").substringAfterLast("/", ""), + title = a.text(), + source = source, + ) + } + } + + override suspend fun getDetails(manga: Manga): Manga { + val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() + val dateFormat = SimpleDateFormat("dd/MM/yyyy", Locale.ROOT) + return manga.copy( + description = doc.selectLastOrThrow(".data p").html(), + tags = doc.selectFirst(".sgeneros")?.select("a")?.mapNotNullToSet { a -> + MangaTag( + key = a.attr("href").removeSuffix("/").substringAfterLast("/", ""), + title = a.text(), + source = source, + ) + }.orEmpty(), + chapters = doc.select(".episodios li a").mapChapters(reversed = true) { i, a -> + val href = a.attrAsRelativeUrl("href") + val title = a.html().substringBeforeLast(" { + val doc = + webClient.httpGet(seed.url.toAbsoluteUrl(domain)).parseHtml().requireElementById("single_relacionados") + return doc.select(".owl-item").map { div -> + val a = div.selectFirstOrThrow("a") + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = a.attrAsAbsoluteUrl("href"), + title = div.selectLastOrThrow(".reltitle h3").text(), + coverUrl = div.selectFirst("img")?.src().orEmpty(), + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + description = null, + state = null, + author = null, + isNsfw = isNsfwSource, + source = source, + ) + } + } + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + return doc.select(".content p img").map { img -> + val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found") + MangaPage( + id = generateUid(url), + url = url, + preview = null, + source = source, + ) + } + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/UnionMangasParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/UnionMangasParser.kt deleted file mode 100644 index c9f2e326b..000000000 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/UnionMangasParser.kt +++ /dev/null @@ -1,175 +0,0 @@ -package org.koitharu.kotatsu.parsers.site.pt - -import org.jsoup.nodes.Element -import org.koitharu.kotatsu.parsers.MangaLoaderContext -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.util.* -import org.koitharu.kotatsu.parsers.util.json.getStringOrNull -import org.koitharu.kotatsu.parsers.util.json.mapJSON -import java.text.SimpleDateFormat -import java.util.* - -@MangaSourceParser("UNION_MANGAS", "Union Mangás", "pt") -class UnionMangasParser(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.UNION_MANGAS, 40) { - - override val sortOrders: Set = EnumSet.of( - SortOrder.ALPHABETICAL, - SortOrder.POPULARITY, - ) - - override val configKeyDomain = ConfigKey.Domain("unionmangasbr.top", "guimah.com") - - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - if (!query.isNullOrEmpty()) { - return if (page == searchPaginator.firstPage) { - search(query) - } else { - emptyList() - } - } - val tag = tags.oneOrThrowIfMany() - val url = urlBuilder() - .addPathSegment("lista-mangas") - .addPathSegment( - when { - tag != null -> tag.key - sortOrder == SortOrder.ALPHABETICAL -> "a-z" - else -> "visualizacoes" - }, - ).addPathSegment(page.toString()) - val doc = webClient.httpGet(url.build()).parseHtml() - val root = doc.selectFirstOrThrow("div.tamanho-bloco-perfil") - return root.select(".lista-mangas").map { div -> - val a = div.selectFirstOrThrow("a") - val img = div.selectFirstOrThrow("img") - val href = a.attrAsRelativeUrl("href") - Manga( - id = generateUid(href), - url = href, - publicUrl = a.attrAsAbsoluteUrl("href"), - title = div.selectLastOrThrow("a").text(), - coverUrl = img.attrAsAbsoluteUrl("src"), - altTitle = null, - rating = RATING_UNKNOWN, - tags = emptySet(), - description = div.selectLast("div")?.ownText(), - state = null, - author = null, - isNsfw = false, - source = source, - ) - } - } - - override suspend fun getDetails(manga: Manga): Manga { - val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() - val root = doc.selectFirstOrThrow(".perfil-d-manga, .perfil-p-manga, .manga-pagina") - val dateFormat = SimpleDateFormat("dd/MM/yyyy", Locale.ROOT) - return manga.copy( - rating = root.select("h2") - .find { it.ownText().startsWith('#') } - ?.ownText()?.drop(1)?.toFloatOrNull()?.div(10f) ?: manga.rating, - largeCoverUrl = root.selectFirst("img.img-thumbnail")?.attrAsAbsoluteUrlOrNull("src"), - description = root.selectFirst(".panel-default")?.selectFirst(".panel-body")?.html(), - author = root.tableValue("Autor")?.ownText(), - altTitle = root.tableValue("Título(s) Alternativo(s)")?.ownText(), - state = when (root.tableValue("Status")?.selectLast(".label")?.text()) { - "Completo" -> MangaState.FINISHED - "Ativo" -> MangaState.ONGOING - else -> null - }, - tags = root.tableValue("Gênero(s)")?.select("a")?.mapToSet { - it.toMangaTag() - } ?: manga.tags, - isNsfw = root.selectFirst(".alert-danger")?.html()?.contains("18 anos") == true, - chapters = root.select("div.row.capitulos").mapChapters(reversed = true) { i, div -> - val a = div.selectFirstOrThrow("a") - val href = a.attrAsRelativeUrl("href") - val title = a.text() - MangaChapter( - id = generateUid(href), - name = title, - number = i + 1, - url = href, - scanlator = div.selectLast("a")?.text()?.takeUnless { it == title }, - uploadDate = dateFormat.tryParse( - a.nextElementSibling()?.text()?.removeSurrounding("(", ")"), - ), - branch = null, - source = source, - ) - }, - ) - } - - override suspend fun getPages(chapter: MangaChapter): List { - val fullUrl = chapter.url.toAbsoluteUrl(domain) - val doc = webClient.httpGet(fullUrl).parseHtml() - return doc.body().selectOrThrow("img[pag]").mapNotNull { img -> - val href = img.attrAsRelativeUrl("src") - if (href.startsWith("/images/banner")) { - return@mapNotNull null - } - MangaPage( - id = generateUid(href), - url = href, - preview = null, - source = source, - ) - } - } - - override suspend fun getTags(): Set { - val doc = webClient.httpGet(urlBuilder().addPathSegment("lista-mangas").build()).parseHtml() - val ul = doc.body().selectFirstOrThrow(".nav-tabs").selectFirstOrThrow("ul.dropdown-menu") - return ul.select("li").mapToSet { li -> - li.selectFirstOrThrow("a").toMangaTag() - } - } - - private suspend fun search(query: String): List { - val domain = domain - val json = webClient.httpGet( - urlBuilder() - .addPathSegments("assets/busca.php") - .addQueryParameter("nomeManga", query) - .build(), - ).parseJson() - return json.getJSONArray("items").mapJSON { jo -> - val href = "/perfil/" + jo.getString("url") - Manga( - id = generateUid(href), - url = href, - publicUrl = href.toAbsoluteUrl(domain), - title = jo.getString("titulo"), - rating = RATING_UNKNOWN, - tags = emptySet(), - author = jo.getStringOrNull("autor"), - coverUrl = jo.getString("imagem"), - state = null, - isNsfw = false, - altTitle = null, - source = source, - ) - } - } - - private fun Element.tableValue(title: String): Element? { - return select("h4.media-heading") - .find { it.selectFirst("label.subtit-manga")?.text()?.contains(title, ignoreCase = true) == true } - } - - private fun Element.toMangaTag() = MangaTag( - title = text().toTitleCase(sourceLocale), - key = attr("href").removeSuffix('/').substringAfterLast('/'), - source = source, - ) -} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/YugenMangas.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/YugenMangas.kt new file mode 100644 index 000000000..4d61c0b7b --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/YugenMangas.kt @@ -0,0 +1,147 @@ +package org.koitharu.kotatsu.parsers.site.pt + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +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.util.* +import org.koitharu.kotatsu.parsers.util.json.mapJSON +import java.text.SimpleDateFormat +import java.util.* + +@MangaSourceParser("YUGENMANGAS", "Yugen Mangas", "pt") +class YugenMangas(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.YUGENMANGAS, 28) { + + override val sortOrders: Set = EnumSet.of(SortOrder.ALPHABETICAL, SortOrder.UPDATED) + + override val configKeyDomain = ConfigKey.Domain("yugenmangas.org") + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + if (!query.isNullOrEmpty()) { + if (page > 1) { + return emptyList() + } + val url = buildString { + append("https://") + append(domain) + append("/api/series/list/?query=") + append(query.urlEncoded()) + } + val json = webClient.httpGet(url).parseJsonArray() + return json.mapJSON { j -> + val urlManga = "https://$domain/series/${j.getString("slug")}/" + Manga( + id = generateUid(urlManga), + url = urlManga, + publicUrl = urlManga, + title = j.getString("name"), + coverUrl = "", + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + description = null, + state = null, + author = null, + isNsfw = false, + source = source, + ) + } + } else { + val url = buildString { + append("https://") + append(domain) + when (sortOrder) { + SortOrder.ALPHABETICAL -> append("/series") + SortOrder.UPDATED -> append("/updates") + else -> append("/updates") + } + if (page > 1) { + append("?page=") + append(page) + } + } + val doc = webClient.httpGet(url).parseHtml() + return doc.select(".gallery .mangas-gallery, .container-update-series .card-series-updates").map { div -> + val a = div.selectFirstOrThrow("a") + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = a.attrAsAbsoluteUrl("href"), + title = div.selectLastOrThrow(".title-serie, .name-manga").text(), + coverUrl = div.selectFirst("img")?.src().orEmpty(), + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + description = null, + state = null, + author = null, + isNsfw = false, + source = source, + ) + } + } + } + + override suspend fun getDetails(manga: Manga): Manga { + val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() + val dateFormat = SimpleDateFormat("dd.MM.yyyy", Locale.ROOT) + val chapters = doc.requireElementById("listadecapitulos") + return manga.copy( + description = doc.selectFirst(".sinopse .sinopse")?.html(), + author = doc.selectFirst(".author")?.text(), + coverUrl = doc.selectFirst(".side img")?.src().orEmpty(), + state = doc.selectFirst(".lancamento p")?.let { + when (it.text().lowercase()) { + "ongoing" -> MangaState.ONGOING + "completed", "finished" -> MangaState.FINISHED + else -> null + } + }, + chapters = chapters.select(".chapter").mapChapters(reversed = true) { i, div -> + val a = div.selectFirstOrThrow("a") + val href = a.attrAsRelativeUrl("href") + val title = div.selectFirstOrThrow(".chapter-title").text() + val dateText = div.selectFirstOrThrow(".chapter-lancado").text() + MangaChapter( + id = generateUid(href), + name = title, + number = i + 1, + url = href, + scanlator = null, + uploadDate = dateFormat.tryParse(dateText), + branch = null, + source = source, + ) + }, + ) + } + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val apiUrl = webClient.httpGet(fullUrl).parseHtml().selectFirstOrThrow("script:containsData(imageUrls)").data() + .substringAfter("apiUrl = \"").substringBefore("\";") + val json = webClient.httpGet(apiUrl.toAbsoluteUrl(domain)).parseJson().getJSONArray("chapter_images") + val pages = ArrayList(json.length()) + for (i in 0 until json.length()) { + val img = "https://media.$domain/${json.getString(i)}" + pages.add( + MangaPage( + id = generateUid(img), + url = img, + preview = null, + source = source, + ), + ) + } + return pages + } + + override suspend fun getTags(): Set = emptySet() +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/DesuMeParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/DesuMeParser.kt index 2b1e1efe9..d66ee9551 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/DesuMeParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/DesuMeParser.kt @@ -15,7 +15,7 @@ import org.koitharu.kotatsu.parsers.util.json.mapJSONIndexed import org.koitharu.kotatsu.parsers.util.json.mapJSONToSet import java.util.* -@MangaSourceParser("DESUME", "Desu.me", "ru") +@MangaSourceParser("DESUME", "Desu .Me", "ru") internal class DesuMeParser(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.DESUME, 20) { override val configKeyDomain = ConfigKey.Domain("desu.me", "desu.win") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/NudeMoonParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/NudeMoonParser.kt index 1ced83d8d..56c16df1e 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/NudeMoonParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/NudeMoonParser.kt @@ -11,8 +11,6 @@ import org.koitharu.kotatsu.parsers.util.* import java.text.SimpleDateFormat import java.util.* -private const val MAX_THUMB_INDEX = 19 - @MangaSourceParser("NUDEMOON", "Nude-Moon", "ru", type = ContentType.HENTAI) internal class NudeMoonParser( context: MangaLoaderContext, diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/RemangaParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/RemangaParser.kt index dee37f30e..eafb78622 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/RemangaParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/RemangaParser.kt @@ -24,7 +24,7 @@ private const val PAGE_SIZE = 30 private const val STATUS_ONGOING = 1 private const val STATUS_FINISHED = 0 -@MangaSourceParser("REMANGA", "Remanga", "ru") +@MangaSourceParser("REMANGA", "Re Manga", "ru") internal class RemangaParser( context: MangaLoaderContext, ) : PagedMangaParser(context, MangaSource.REMANGA, PAGE_SIZE), MangaParserAuthProvider { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/grouple/ReadmangaParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/grouple/ReadmangaParser.kt index 473f8b2a2..1e895a596 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/grouple/ReadmangaParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/grouple/ReadmangaParser.kt @@ -5,7 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.config.ConfigKey import org.koitharu.kotatsu.parsers.model.MangaSource -@MangaSourceParser("READMANGA_RU", "ReadManga", "ru") +@MangaSourceParser("READMANGA_RU", "Read Manga", "ru") internal class ReadmangaParser( context: MangaLoaderContext, ) : GroupleParser(context, MangaSource.READMANGA_RU, 1) { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/grouple/SelfMangaParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/grouple/SelfMangaParser.kt index a37884bd8..d1ea7bb20 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/grouple/SelfMangaParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/grouple/SelfMangaParser.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.config.ConfigKey import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource -@MangaSourceParser("SELFMANGA", "SelfManga", "ru", type = ContentType.OTHER) +@MangaSourceParser("SELFMANGA", "Self Manga", "ru", type = ContentType.OTHER) internal class SelfMangaParser( context: MangaLoaderContext, ) : GroupleParser(context, MangaSource.SELFMANGA, 3) { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/rulib/YaoiLibParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/rulib/YaoiLibParser.kt index 68c13efc4..2cace15c5 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/rulib/YaoiLibParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/rulib/YaoiLibParser.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.config.ConfigKey import org.koitharu.kotatsu.parsers.model.MangaSource -@MangaSourceParser("YAOILIB", "YaoiLib", "ru") +@MangaSourceParser("YAOILIB", "Yaoi Lib", "ru") internal class YaoiLibParser(context: MangaLoaderContext) : MangaLibParser(context, MangaSource.YAOILIB) { override val configKeyDomain = ConfigKey.Domain("yaoilib.me") override fun isNsfw(doc: Document) = true diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/sinmh/SinmhParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/sinmh/SinmhParser.kt index 6f3499f19..093292952 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/sinmh/SinmhParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/sinmh/SinmhParser.kt @@ -122,7 +122,7 @@ internal abstract class SinmhParser( val doc = webClient.httpGet(fullUrl).parseHtml() val body = doc.body() - val chapters = getChapters(manga, doc) + val chapters = getChapters(doc) val desc = body.selectFirst(selectDesc)?.html() @@ -150,7 +150,7 @@ internal abstract class SinmhParser( protected open val selectChapter = "ul#chapter-list-1 li" - protected open suspend fun getChapters(manga: Manga, doc: Document): List { + protected open suspend fun getChapters(doc: Document): List { return doc.body().select(selectChapter).mapChapters { i, li -> val href = li.selectFirstOrThrow("a").attrAsRelativeUrl("href") val name = li.selectFirstOrThrow("a").text() diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/tr/MangaAy.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/tr/MangaAy.kt new file mode 100644 index 000000000..923597488 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/tr/MangaAy.kt @@ -0,0 +1,157 @@ +package org.koitharu.kotatsu.parsers.site.tr + +import androidx.collection.ArrayMap +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import org.koitharu.kotatsu.parsers.MangaLoaderContext +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.util.* +import java.text.SimpleDateFormat +import java.util.* + +@MangaSourceParser("MANGAAY", "Manga Ay", "tr") +class MangaAy(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.MANGAAY, 45) { + + override val sortOrders: Set = EnumSet.of(SortOrder.UPDATED) + + override val configKeyDomain = ConfigKey.Domain("manga-ay.com") + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + val tag = tags.oneOrThrowIfMany() + if (!query.isNullOrEmpty() || !tags.isNullOrEmpty()) { + if (page > 1) { + return emptyList() + } + val url = "https://$domain/arama" + val doc = webClient.httpPost( + url, + mapOf( + "title" to query?.urlEncoded().orEmpty(), + "genres" to tag?.key.orEmpty(), + ), + ).parseHtml() + return doc.select(".table tr").map { tr -> + val a = tr.selectFirstOrThrow("a") + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = a.attrAsAbsoluteUrl("href"), + title = a.text(), + coverUrl = "", + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + description = null, + state = null, + author = null, + isNsfw = isNsfwSource, + source = source, + ) + } + } else { + val url = buildString { + append("https://") + append(domain) + append("/seriler") + if (page > 1) { + append("/") + append(page) + } + } + val doc = webClient.httpGet(url).parseHtml().requireElementById("ecommerce-products") + return doc.select(".card").map { div -> + val a = div.selectFirstOrThrow("a") + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = a.attrAsAbsoluteUrl("href"), + title = div.selectLastOrThrow(".item-name").text(), + coverUrl = div.selectFirst("img")?.src().orEmpty(), + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + description = null, + state = null, + author = null, + isNsfw = isNsfwSource, + source = source, + ) + } + } + } + + private var tagCache: ArrayMap? = null + private val mutex = Mutex() + + override suspend fun getTags(): Set { + return getOrCreateTagMap().values.toSet() + } + + private suspend fun getOrCreateTagMap(): Map = mutex.withLock { + tagCache?.let { return@withLock it } + val tagMap = ArrayMap() + val tagElements = webClient.httpGet("https://$domain/arama").parseHtml() + .requireElementById("genres").select("option") + for (option in tagElements) { + if (option.text().isEmpty()) continue + tagMap[option.text()] = MangaTag( + key = option.attr("value"), + title = option.text(), + source = source, + ) + } + tagCache = tagMap + return@withLock tagMap + } + + override suspend fun getDetails(manga: Manga): Manga { + val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() + val dateFormat = SimpleDateFormat("dd/MM/yyyy HH:mm:ss", Locale.ROOT) + val tagMap = getOrCreateTagMap() + val tags = doc.select("P.card-text .bg-success").mapNotNullToSet { tagMap[it.text()] } + return manga.copy( + description = doc.selectFirst("p.card-text")?.html()?.substringAfterLast("
"), + coverUrl = doc.selectFirst("div.align-items-center div.align-items-center img")?.src().orEmpty(), + tags = tags, + chapters = doc.requireElementById("sonyuklemeler").select("tbody tr") + .mapChapters(reversed = true) { i, tr -> + val a = tr.selectFirstOrThrow("a") + val href = a.attrAsRelativeUrl("href") + MangaChapter( + id = generateUid(href), + name = a.text(), + number = i + 1, + url = href, + scanlator = null, + uploadDate = dateFormat.tryParse(tr.selectFirstOrThrow("time").attr("datetime")), + branch = null, + source = source, + ) + }, + ) + } + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + return doc.select("div.mt-2 img").map { img -> + val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found") + MangaPage( + id = generateUid(url), + url = url, + preview = null, + source = source, + ) + } + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/tr/YaoiFlix.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/tr/YaoiFlix.kt new file mode 100644 index 000000000..b365ad36b --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/tr/YaoiFlix.kt @@ -0,0 +1,136 @@ +package org.koitharu.kotatsu.parsers.site.tr + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +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.util.* +import java.text.SimpleDateFormat +import java.util.* + +@MangaSourceParser("YAOIFLIX", "Yaoi Flix", "tr", ContentType.HENTAI) +class YaoiFlix(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.YAOIFLIX, 8) { + + override val sortOrders: Set = EnumSet.of(SortOrder.UPDATED) + + override val configKeyDomain = ConfigKey.Domain("www.yaoiflix.cc") + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + val tag = tags.oneOrThrowIfMany() + val url = buildString { + append("https://") + append(domain) + when { + !query.isNullOrEmpty() -> { + if (page > 1) { + append("/page/") + append(page) + } + append("/?s=") + append(query.urlEncoded()) + } + + !tags.isNullOrEmpty() -> { + append("/dizi-kategori/") + append(tag?.key.orEmpty()) + append("/") + if (page > 1) { + append("page/") + append(page) + append("/") + } + } + + else -> { + append("/tum-seriler/") + if (page > 1) { + append("page/") + append(page) + append("/") + } + } + } + } + val doc = webClient.httpGet(url).parseHtml() + return doc.select(".list_items .series-box").map { div -> + val a = div.selectFirstOrThrow("a") + val href = a.attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = a.attrAsAbsoluteUrl("href"), + title = div.selectLastOrThrow(".name").text(), + coverUrl = div.selectFirst("img")?.src().orEmpty(), + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + description = null, + state = null, + author = null, + isNsfw = isNsfwSource, + source = source, + ) + } + } + + override suspend fun getTags(): Set { + val doc = webClient.httpGet("https://$domain").parseHtml() + return doc.select(".tags .cat-item a").mapNotNullToSet { a -> + MangaTag( + key = a.attr("href").removeSuffix('/').substringAfterLast('/'), + title = a.text(), + source = source, + ) + } + } + + override suspend fun getDetails(manga: Manga): Manga { + val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() + val dateFormat = SimpleDateFormat("dd MMM", sourceLocale) + return manga.copy( + description = doc.selectFirst(".description")?.html()?.substringAfterLast("
"), + tags = doc.select(".category a").mapNotNullToSet { a -> + MangaTag( + key = a.attr("href").removeSuffix('/').substringAfterLast('/'), + title = a.text(), + source = source, + ) + }, + chapters = doc.select(".serie-content .ep-box") + .mapChapters(reversed = true) { i, div -> + val a = div.selectFirstOrThrow("a") + val href = a.attrAsRelativeUrl("href") + MangaChapter( + id = generateUid(href), + name = a.text(), + number = i + 1, + url = href, + scanlator = null, + uploadDate = dateFormat.tryParse(div.selectFirstOrThrow(".date").text()), + branch = null, + source = source, + ) + }, + ) + } + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + return doc.select(".video-content img").map { img -> + val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found") + MangaPage( + id = generateUid(url), + url = url, + preview = null, + source = source, + ) + } + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/uk/HentaiUkrParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/uk/HentaiUkrParser.kt index 133d2e003..126718fac 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/uk/HentaiUkrParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/uk/HentaiUkrParser.kt @@ -79,14 +79,14 @@ class HentaiUkrParser(context: MangaLoaderContext) : MangaParser(context, MangaS val ids = tags.mapToSet { it.key } json.retainAll { item -> item.getJSONArray("tags") - .mapJSON { it.getAsString("id") } + .mapJSON { it.getAsString() } .any { x -> x in ids } } } // Return to app return json.drop(offset).take(PAGE_SIZE).map { jo -> - val id = jo.getAsLong("id") + val id = jo.getAsLong() Manga( id = generateUid(id), title = jo.getString("name"), @@ -124,7 +124,7 @@ class HentaiUkrParser(context: MangaLoaderContext) : MangaParser(context, MangaS x.getJSONArray("tags").mapJSON { t -> MangaTag( title = t.getString("name"), - key = t.getAsString("id"), + key = t.getAsString(), source = source, ) } @@ -138,7 +138,7 @@ class HentaiUkrParser(context: MangaLoaderContext) : MangaParser(context, MangaS tagsSet.add( MangaTag( title = item.getString("name"), - key = item.getAsString("id"), + key = item.getAsString(), source = source, ), ) @@ -157,8 +157,8 @@ class HentaiUkrParser(context: MangaLoaderContext) : MangaParser(context, MangaS return chain.proceed(newRequest) } - private fun JSONObject.getAsLong(name: String): Long { - val rawValue = opt(name) + private fun JSONObject.getAsLong(): Long { + val rawValue = opt("id") return when (rawValue) { null, JSONObject.NULL -> null is Long -> rawValue @@ -168,7 +168,7 @@ class HentaiUkrParser(context: MangaLoaderContext) : MangaParser(context, MangaS } ?: error("Cannot read value $rawValue as Long") } - private fun JSONObject.getAsString(name: String): String { - return get(name).toString() + private fun JSONObject.getAsString(): String { + return get("id").toString() } } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/uk/MangaInUaParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/uk/MangaInUaParser.kt index 2e575665a..60468af67 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/uk/MangaInUaParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/uk/MangaInUaParser.kt @@ -34,7 +34,7 @@ class MangaInUaParser(context: MangaLoaderContext) : PagedMangaParser( sortOrder: SortOrder, ): List { val url = when { - !query.isNullOrEmpty() -> ("/index.php?do=search" + "&subaction=search" + "&search_start=$page" + "&full_search=1" + "&story=$query" + "&titleonly=3").toAbsoluteUrl( + !query.isNullOrEmpty() -> ("/index.php?do=search&subaction=search&search_start=$page&full_search=1&story=$query&titleonly=3").toAbsoluteUrl( domain, ) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/vi/HentaiVNParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/vi/HentaiVNParser.kt index a5059ab5d..145bcc3e5 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/vi/HentaiVNParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/vi/HentaiVNParser.kt @@ -1,10 +1,12 @@ package org.koitharu.kotatsu.parsers.site.vi +import androidx.collection.ArrayMap import kotlinx.coroutines.async import kotlinx.coroutines.coroutineScope +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock import okhttp3.Headers import org.jsoup.nodes.Document -import org.jsoup.nodes.Element import org.koitharu.kotatsu.parsers.MangaLoaderContext import org.koitharu.kotatsu.parsers.MangaParser import org.koitharu.kotatsu.parsers.MangaSourceParser @@ -33,15 +35,11 @@ class HentaiVNParser(context: MangaLoaderContext) : MangaParser(context, MangaSo SortOrder.NEWEST, ) - private val tagCache = SuspendLazy(this::fetchTags) - override suspend fun getDetails(manga: Manga): Manga = coroutineScope { val chapterDeferred = async { fetchChapters(manga.url) } val docs = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() val id = docs.location().substringAfterLast("/").substringBefore("-") - val genreUrl = Regex(""""(list-info-theloai-mobile\.php?.+)"""").find(docs.toString())?.groupValues?.get(1) - val genreDeferred = async { webClient.httpGet("https://$domain/$genreUrl").parseHtml().select("a.tag") } @@ -51,19 +49,16 @@ class HentaiVNParser(context: MangaLoaderContext) : MangaParser(context, MangaSo val stateDocDeferred = async { webClient.httpGet("/list-info-time-mobile.php?id_anime=$id".toAbsoluteUrl(domain)).parseHtml() } - val genre = genreDeferred.await() + val tagMap = getOrCreateTagMap() + val tags = genre.mapNotNullToSet { tagMap[it.text()] } val infoEl = infoElDeferred.await() val stateDoc = stateDocDeferred.await() manga.copy( - altTitle = infoEl.infoText("Tên Khác:"), + altTitle = infoEl.selectFirst("span.info:contains(Tên Khác:)")?.parent()?.select("span:not(.info) > a")?.joinToString { it.text() }, author = infoEl.select("p:contains(Tác giả:) a").text(), description = infoEl.select("p:contains(Nội dung:) + p").html(), - tags = tagCache.tryGet().getOrNull()?.let { tagMap -> - genre.mapNotNullToSet { - tagMap[it.text()] - } - }.orEmpty(), + tags = tags, state = stateDoc.select("p:contains(Tình Trạng:) a").firstOrNull()?.text()?.let { when (it) { "Đã hoàn thành" -> MangaState.FINISHED @@ -138,20 +133,27 @@ class HentaiVNParser(context: MangaLoaderContext) : MangaParser(context, MangaSo } } + private var tagCache: ArrayMap? = null + private val mutex = Mutex() + override suspend fun getTags(): Set { - return tagCache.get().values.toSet() + return getOrCreateTagMap().values.toSet() } - private suspend fun fetchTags(): Map { - val url = "/forum/search-plus.php".toAbsoluteUrl(domain) - val docs = webClient.httpGet(url).parseHtml() - return docs.selectFirstOrThrow("ul.ul-search").select("li").mapNotNull { el -> - MangaTag( + private suspend fun getOrCreateTagMap(): Map = mutex.withLock { + tagCache?.let { return@withLock it } + val tagMap = ArrayMap() + val tags = webClient.httpGet("/forum/search-plus.php".toAbsoluteUrl(domain)).parseHtml().selectFirstOrThrow("ul.ul-search").select("li") + for (el in tags) { + if (el.text().isEmpty()) continue + tagMap[el.text()] = MangaTag( title = el.text(), - key = el.selectFirst("input")?.attr("value") ?: return@mapNotNull null, + key = el.selectFirst("input")?.attr("value") ?: continue, source = source, ) - }.associateBy { it.title } + } + tagCache = tagMap + return@withLock tagMap } private fun getSortCookies(sortOrder: SortOrder): Array { @@ -166,15 +168,15 @@ class HentaiVNParser(context: MangaLoaderContext) : MangaParser(context, MangaSo } private fun parseMainList(docs: Document, page: Int): List { - val realPage = docs.selectFirst("div.pagination b.pagination-selected")?.text()?.toIntOrNull() ?: 1 + val realPage = docs.selectFirst(".pagination li b")?.text()?.toIntOrNull() ?: 1 if (page > realPage) { return emptyList() } return docs.selectFirstOrThrow("div.main").selectFirstOrThrow("div.block-item").select("ul > li.item") .map { el -> - val relativeUrl = el.selectFirstOrThrow("div.box-cover-2 > a").attrAsRelativeUrl("href") - val descriptionsEl = el.selectFirstOrThrow("div.box-description-2") + val relativeUrl = el.selectFirstOrThrow("div.box-cover > a, div.box-cover-2 > a").attrAsRelativeUrl("href") + val descriptionsEl = el.selectFirstOrThrow("div.box-description, div.box-description-2") Manga( id = generateUid(relativeUrl), title = descriptionsEl.selectFirst("a")?.text().orEmpty(), @@ -183,7 +185,7 @@ class HentaiVNParser(context: MangaLoaderContext) : MangaParser(context, MangaSo publicUrl = relativeUrl.toAbsoluteUrl(domain), rating = RATING_UNKNOWN, isNsfw = true, - coverUrl = el.selectFirst("div.box-cover-2 img")?.src().orEmpty(), + coverUrl = el.selectFirst("div.box-cover img, div.box-cover-2 img")?.src().orEmpty(), tags = emptySet(), state = null, author = null, @@ -239,8 +241,5 @@ class HentaiVNParser(context: MangaLoaderContext) : MangaParser(context, MangaSo ) } } - - private fun Element.infoText(title: String) = - selectFirst("span.info:contains($title)")?.parent()?.select("span:not(.info) > a")?.joinToString { it.text() } } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/vi/Truyenqq.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/vi/Truyenqq.kt new file mode 100644 index 000000000..b307ff318 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/vi/Truyenqq.kt @@ -0,0 +1,136 @@ +package org.koitharu.kotatsu.parsers.site.vi + +import org.koitharu.kotatsu.parsers.MangaLoaderContext +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.util.* +import java.text.SimpleDateFormat +import java.util.* + +@MangaSourceParser("TRUYENQQ", "Truyenqq", "vi") +internal class Truyenqq(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.TRUYENQQ, 42) { + + override val sortOrders: Set = EnumSet.of(SortOrder.UPDATED, SortOrder.POPULARITY, SortOrder.NEWEST) + override val configKeyDomain = ConfigKey.Domain("truyenqqvn.com") + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + val tagQuery = if (tags.isNullOrEmpty()) "" else tags.joinToString(separator = ",") { it.key } + val url = if (!query.isNullOrEmpty()) { + buildString { + append("https://") + append(domain) + append("/tim-kiem/trang-$page.html") + append("?q=") + append(query.urlEncoded()) + } + } else { + buildString { + append("https://") + append(domain) + append("/tim-kiem-nang-cao/trang-$page.html") + append("?status=-1&country=0&sort=") + when (sortOrder) { + SortOrder.POPULARITY -> append("4") + SortOrder.UPDATED -> append("2") + SortOrder.NEWEST -> append("0") + else -> append("2") + } + append("&category=") + append(tagQuery) + append("¬category=&minchapter=0") + } + } + val doc = webClient.httpGet(url).parseHtml() + return doc.requireElementById("main_homepage").select("li").map { li -> + val href = li.selectFirstOrThrow("a").attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + title = li.selectFirstOrThrow(".book_name").text(), + altTitle = null, + url = href, + publicUrl = href.toAbsoluteUrl(domain), + rating = RATING_UNKNOWN, + isNsfw = isNsfwSource, + coverUrl = li.selectFirstOrThrow("img").src().orEmpty(), + tags = emptySet(), + state = null, + author = null, + source = source, + ) + } + } + + override suspend fun getTags(): Set { + val doc = webClient.httpGet("https://$domain/tim-kiem-nang-cao.html").parseHtml() + return doc.select(".advsearch-form div.genre-item").mapNotNullToSet { + MangaTag( + key = it.selectFirstOrThrow("span").attr("data-id"), + title = it.text(), + source = source, + ) + } + } + + + override suspend fun getDetails(manga: Manga): Manga { + val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() + val dateFormat = SimpleDateFormat("dd/MM/yyyy", Locale.ENGLISH) + return manga.copy( + altTitle = doc.selectFirst("h2.other-name")?.text(), + tags = doc.select("ul.list01 li").mapNotNullToSet { + val key = it.attr("href").substringAfterLast("-").substringBeforeLast(".") + MangaTag( + key = key, + title = it.text(), + source = source, + ) + }, + state = when (doc.selectFirstOrThrow(".status p.col-xs-9").text()) { + "Đang Cập Nhật" -> MangaState.ONGOING + "Hoàn Thành" -> MangaState.FINISHED + else -> null + }, + author = doc.selectFirst("li.author a")?.text(), + description = doc.selectFirst(".story-detail-info")?.html(), + chapters = doc.select("div.list_chapter div.works-chapter-item").mapChapters(reversed = true) { i, div -> + val a = div.selectFirstOrThrow("a") + val href = a.attrAsRelativeUrl("href") + val name = a.text() + val dateText = div.selectFirstOrThrow(".time-chap").text() + MangaChapter( + id = generateUid(href), + name = name, + number = i + 1, + url = href, + scanlator = null, + uploadDate = dateFormat.tryParse(dateText), + branch = null, + source = source, + ) + }, + ) + } + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + val root = doc.body().selectFirstOrThrow(".chapter_content") + return root.select("div.page-chapter").map { div -> + val img = div.selectFirstOrThrow("img") + val url = img.src()?.toRelativeUrl(domain) ?: div.parseFailed("Image src not found") + MangaPage( + id = generateUid(url), + url = url, + preview = null, + source = source, + ) + } + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/vi/YurinekoParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/vi/YurinekoParser.kt index a7d390ad3..2b62d2c2f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/vi/YurinekoParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/vi/YurinekoParser.kt @@ -33,7 +33,7 @@ import java.text.SimpleDateFormat import java.util.EnumSet import java.util.Locale -@MangaSourceParser("YURINEKO", "Yurineko", "vi", ContentType.HENTAI) +@MangaSourceParser("YURINEKO", "Yuri Neko", "vi", ContentType.HENTAI) class YurinekoParser(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.YURINEKO, 20) { override val configKeyDomain: ConfigKey.Domain get() = ConfigKey.Domain("yurineko.net") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/WpComicsParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/WpComicsParser.kt index cbf902aaf..6906942da 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/WpComicsParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/WpComicsParser.kt @@ -126,7 +126,7 @@ internal abstract class WpComicsParser( val fullUrl = manga.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() - val chaptersDeferred = async { getChapters(manga, doc) } + val chaptersDeferred = async { getChapters(doc) } val desc = doc.selectFirstOrThrow(selectDesc).html() @@ -162,7 +162,7 @@ internal abstract class WpComicsParser( protected open val selectDate = "div.col-xs-4" protected open val selectChapter = "div#nt_listchapter li:not(.heading)" - protected open suspend fun getChapters(manga: Manga, doc: Document): List { + protected open suspend fun getChapters(doc: Document): List { return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/ZMangaParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/ZMangaParser.kt index bbe8e1783..ec1aa9c2f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/ZMangaParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/ZMangaParser.kt @@ -140,7 +140,7 @@ internal abstract class ZMangaParser( val fullUrl = manga.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() - val chaptersDeferred = async { getChapters(manga, doc) } + val chaptersDeferred = async { getChapters(doc) } val desc = doc.selectFirstOrThrow(selectDesc).html() @@ -179,7 +179,7 @@ internal abstract class ZMangaParser( protected open val selectDate = "span.date" protected open val selectChapter = "ul.series-chapterlist li" - protected open suspend fun getChapters(manga: Manga, doc: Document): List { + protected open suspend fun getChapters(doc: Document): List { val dateFormat = SimpleDateFormat(datePattern, sourceLocale) return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/KomikIndoInfo.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/KomikIndoInfo.kt index 1268a15dc..f67975317 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/KomikIndoInfo.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/KomikIndoInfo.kt @@ -6,7 +6,7 @@ import org.koitharu.kotatsu.parsers.model.ContentType import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.zmanga.ZMangaParser -@MangaSourceParser("KOMIKINDO_INFO", "KomikIndo .Info", "id", ContentType.HENTAI) +@MangaSourceParser("KOMIKINDO_INFO", "Komik Indo .Info", "id", ContentType.HENTAI) internal class KomikIndoInfo(context: MangaLoaderContext) : ZMangaParser(context, MangaSource.KOMIKINDO_INFO, "komikindo.info") { override val datePattern = "dd MMM yyyy" diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/MaidId.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/MaidId.kt index d3348fde2..4a7e01b70 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/MaidId.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/MaidId.kt @@ -3,7 +3,6 @@ package org.koitharu.kotatsu.parsers.site.zmanga.id import org.jsoup.nodes.Document import org.koitharu.kotatsu.parsers.MangaLoaderContext import org.koitharu.kotatsu.parsers.MangaSourceParser -import org.koitharu.kotatsu.parsers.model.Manga import org.koitharu.kotatsu.parsers.model.MangaChapter import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.zmanga.ZMangaParser @@ -18,7 +17,7 @@ import java.text.SimpleDateFormat internal class MaidId(context: MangaLoaderContext) : ZMangaParser(context, MangaSource.MAID_ID, "www.maid.my.id") { - override suspend fun getChapters(manga: Manga, doc: Document): List { + override suspend fun getChapters(doc: Document): List { val dateFormat = SimpleDateFormat(datePattern, sourceLocale) return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/ShiroDoujin.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/ShiroDoujin.kt index d12c64da0..56f0a3f2b 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/ShiroDoujin.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/ShiroDoujin.kt @@ -4,7 +4,6 @@ import org.jsoup.nodes.Document 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.Manga import org.koitharu.kotatsu.parsers.model.MangaChapter import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.zmanga.ZMangaParser @@ -18,7 +17,7 @@ import java.text.SimpleDateFormat internal class ShiroDoujin(context: MangaLoaderContext) : ZMangaParser(context, MangaSource.SHIRO_DOUJIN, "shirodoujin.com") { - override suspend fun getChapters(manga: Manga, doc: Document): List { + override suspend fun getChapters(doc: Document): List { val dateFormat = SimpleDateFormat(datePattern, sourceLocale) return doc.body().select(selectChapter).mapChapters(reversed = true) { i, li -> val a = li.selectFirstOrThrow("a") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/util/Jsoup.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/util/Jsoup.kt index d4091b9e9..9d2e0e595 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/util/Jsoup.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/util/Jsoup.kt @@ -155,7 +155,7 @@ fun Element.attrOrNull(vararg names: String): String? { } @JvmOverloads -fun Element.src(names: Array = arrayOf("data-src", "data-cfsrc", "data-original", "data-cdn", "data-sizes", "data-lazy-src", "data-srcset", "original-src", "src")): String? { +fun Element.src(names: Array = arrayOf("data-src", "data-cfsrc", "data-original", "data-cdn", "data-sizes", "data-lazy-src", "data-srcset", "original-src", "data-wpfc-original-src", "src")): String? { for (name in names) { val value = attrAsAbsoluteUrlOrNull(name) if (value != null) {