From 47dde65f658257d77b5bcba0832e07a0b161f162 Mon Sep 17 00:00:00 2001 From: devi Date: Sat, 5 Aug 2023 18:04:13 +0200 Subject: [PATCH 1/3] fix and add sources --- .../kotatsu/parsers/site/en/DynastyScans.kt | 172 +++++++++++++++ .../kotatsu/parsers/site/en/Mangaowl.kt | 199 ++++++++++++++++++ .../kotatsu/parsers/site/en/TempleScan.kt | 133 ++++++++++++ .../parsers/site/fr/BentomangaParser.kt | 2 +- .../kotatsu/parsers/site/fr/FuryoSociety.kt | 158 ++++++++++++++ .../parsers/site/madara/MadaraParser.kt | 8 +- .../parsers/site/madara/ar/Azoranov.kt | 4 +- .../parsers/site/madara/ar/GateManga.kt | 1 + .../parsers/site/madara/ar/WebtoonEmpire.kt | 1 + .../parsers/site/madara/en/BestManhuaCom.kt | 125 +++++++++++ .../parsers/site/madara/en/BoysLove.kt | 1 + .../parsers/site/madara/en/DarkScans.kt | 5 +- .../parsers/site/madara/en/DrakeScans.kt | 1 + .../site/madara/en/FreeWebtoonCoins.kt | 1 + .../en/{TempleScan.kt => GourmetScans.kt} | 9 +- .../kotatsu/parsers/site/madara/en/Grabber.kt | 1 + .../kotatsu/parsers/site/madara/en/HManhwa.kt | 2 +- .../parsers/site/madara/en/Hentai4Free.kt | 92 ++++++++ .../parsers/site/madara/en/ImmortalUpdates.kt | 4 +- .../parsers/site/madara/en/IsekaiScan.kt | 4 + .../parsers/site/madara/en/KissManga.kt | 1 + .../parsers/site/madara/en/LilyManga.kt | 1 + .../parsers/site/madara/en/MangaBaz.kt | 5 +- .../parsers/site/madara/en/MangaDistrict.kt | 1 - .../parsers/site/madara/en/MangaHentai.kt | 1 + .../parsers/site/madara/en/MangaLeveling.kt | 2 +- .../parsers/site/madara/en/Manhuamix.kt | 1 + .../parsers/site/madara/en/Manhuasy.kt | 1 + .../parsers/site/madara/en/ManhwaFull.kt | 1 + .../parsers/site/madara/en/ManhwaHentai.kt | 1 + .../parsers/site/madara/en/ManyToon.kt | 4 +- .../parsers/site/madara/en/ManyToonMe.kt | 5 +- .../parsers/site/madara/en/ReadFreeComics.kt | 1 + .../site/madara/en/SleepyTranslations.kt | 1 + .../kotatsu/parsers/site/madara/en/Toonily.kt | 1 + .../parsers/site/madara/en/WebtoonXyz.kt | 1 + .../parsers/site/madara/en/Webtoons.kt | 1 + .../parsers/site/madara/en/Woopread.kt | 1 + .../parsers/site/madara/en/ZandynoFansub.kt | 1 + .../site/madara/es/AiyuMangaScanlation.kt | 6 +- .../parsers/site/madara/es/DoujinHentaiNet.kt | 40 ++++ .../parsers/site/madara/es/MangaMundoDrama.kt | 4 +- .../parsers/site/madara/es/RagnarokScan.kt | 2 +- .../kotatsu/parsers/site/madara/fr/FrScan.kt | 2 +- .../parsers/site/madara/fr/KaratcamScans.kt | 1 + .../parsers/site/madara/fr/MangasOrigines.kt | 2 + .../kotatsu/parsers/site/madara/fr/ToonFr.kt | 1 + .../parsers/site/madara/id/GourmetScansId.kt | 15 ++ .../parsers/site/madara/id/Komiksay.kt | 1 + .../kotatsu/parsers/site/madara/id/Mgkomik.kt | 1 + .../parsers/site/madara/id/PojokManga.kt | 1 + .../parsers/site/madara/id/Shinigami.kt | 1 + .../parsers/site/madara/pt/WickedWitchScan.kt | 13 ++ .../parsers/site/madara/pt/YugenMangas.kt | 4 +- .../parsers/site/madara/ru/Mangazavr.kt | 1 + .../site/madara/tr/Cizgiromanarsivi.kt | 3 +- .../parsers/site/madara/tr/DiamondFansub.kt | 1 + .../parsers/site/madara/tr/Mangabilgini.kt | 17 -- .../site/mangareader/MangaReaderParser.kt | 19 +- .../parsers/site/mangareader/ar/SwaTeam.kt | 13 +- .../parsers/site/mangareader/en/BabelToon.kt | 2 +- .../parsers/site/mangareader/en/PeaceScans.kt | 10 + .../site/mangareader/fr/PantheonScanFr.kt | 10 + .../parsers/site/mangareader/id/KomikSan.kt | 75 +++++++ .../parsers/site/mangareader/id/Komikcast.kt | 4 +- .../site/mangareader/pt/SssScanlator.kt | 10 + .../parsers/site/mmrcms/fr/FrScansCom.kt | 14 ++ .../koitharu/kotatsu/parsers/site/pt/Bakai.kt | 155 ++++++++++++++ .../kotatsu/parsers/site/pt/GoldenManga.kt | 143 +++++++++++++ .../parsers/site/wpcomics/WpComicsParser.kt | 24 +-- .../parsers/site/wpcomics/en/XoxoComics.kt | 42 ++-- .../parsers/site/wpcomics/vi/Nettruyenmax.kt | 2 +- .../parsers/site/zmanga/ZMangaParser.kt | 2 +- .../kotatsu/parsers/site/zmanga/id/MaidId.kt | 5 +- .../parsers/site/zmanga/id/ShiroDoujin.kt | 5 +- .../koitharu/kotatsu/parsers/util/Jsoup.kt | 2 +- 76 files changed, 1497 insertions(+), 110 deletions(-) create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/DynastyScans.kt create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Mangaowl.kt create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/TempleScan.kt create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/FuryoSociety.kt create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BestManhuaCom.kt rename src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/{TempleScan.kt => GourmetScans.kt} (55%) create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/DoujinHentaiNet.kt create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/GourmetScansId.kt create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/WickedWitchScan.kt delete mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Mangabilgini.kt create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/PeaceScans.kt create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/PantheonScanFr.kt create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/KomikSan.kt create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pt/SssScanlator.kt create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/FrScansCom.kt create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/Bakai.kt create mode 100644 src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/GoldenManga.kt diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/DynastyScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/DynastyScans.kt new file mode 100644 index 00000000..1609dc27 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/DynastyScans.kt @@ -0,0 +1,172 @@ +package org.koitharu.kotatsu.parsers.site.en + +import okhttp3.Headers +import org.json.JSONArray +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.network.UserAgents +import org.koitharu.kotatsu.parsers.util.* +import java.text.SimpleDateFormat +import java.util.* + +@MangaSourceParser("DYNASTYSCANS", "Dynasty Scans", "en") +internal class DynastyScans(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.DYNASTYSCANS, 117) { + override val sortOrders: Set = EnumSet.of(SortOrder.ALPHABETICAL) + override val configKeyDomain = ConfigKey.Domain("dynasty-scans.com") + + 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 url = buildString { + append("https://") + append(domain) + if (!query.isNullOrEmpty()) { + append("/search?q=") + append(query.urlEncoded()) + append("&") + append("classes[]".urlEncoded()) + append("=Serie&page=") + append(page.toString()) + } else if (!tags.isNullOrEmpty()) { + append("/tags/") + for (tag in tags) { + append(tag.key) + } + append("?view=groupings&page=") + append(page.toString()) + } else { + append("/series?view=cover&page=") + append(page.toString()) + } + } + val doc = webClient.httpGet(url).parseHtml() + + //There are no images on the search page + if (!query.isNullOrEmpty()) { + return doc.select("dl.chapter-list dd") + .map { div -> + val href = div.selectFirstOrThrow("a").attrAsAbsoluteUrl("href") + Manga( + id = generateUid(href), + title = div.selectFirstOrThrow("a").text(), + altTitle = null, + url = href, + publicUrl = href.toAbsoluteUrl(domain), + rating = RATING_UNKNOWN, + isNsfw = false, + coverUrl = "", + tags = div.select("span.tags a").mapNotNullToSet { a -> + MangaTag( + key = a.attr("href").removeSuffix('/').substringAfterLast('/'), + title = a.text(), + source = source, + ) + }, + state = null, + author = null, + source = source, + ) + } + } else { + return doc.select("li.span2") + .map { div -> + val href = div.selectFirstOrThrow("a").attrAsAbsoluteUrl("href") + Manga( + id = generateUid(href), + title = div.selectFirstOrThrow("div.caption").text(), + altTitle = null, + url = href, + publicUrl = href.toAbsoluteUrl(domain), + rating = RATING_UNKNOWN, + isNsfw = false, + coverUrl = div.selectFirstOrThrow("img").attrAsAbsoluteUrl("src"), + tags = setOf(), + 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 chapters = getChapters(doc) + val root = doc.requireElementById("main") + return manga.copy( + altTitle = null, + state = when (root.select("h2.tag-title small").last()?.text()) { + "— Ongoing" -> MangaState.ONGOING + "— Completed" -> MangaState.FINISHED + else -> null + }, + coverUrl = root.selectFirst("img.thumbnail")?.src() + .orEmpty(), // It is needed if the manga was found via the search. + tags = root.select("div.tag-tags a").mapNotNullToSet { a -> + val href = a.attr("href").removeSuffix('/').substringAfterLast('/') + MangaTag( + key = href, + title = a.text(), + source = source, + ) + }, + author = null, + description = null, + chapters = chapters, + ) + } + + private fun getChapters(doc: Document): List { + val dateFormat = SimpleDateFormat("MMM dd yy", sourceLocale) + return doc.body().select("dl.chapter-list dd").mapChapters { i, li -> + val a = li.selectFirstOrThrow("a") + val href = a.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") + val dateText = li.select("small").last()?.text()?.replace("released ", "")?.replace("'", "") + MangaChapter( + id = generateUid(href), + name = a.text(), + number = i + 1, + url = href, + uploadDate = dateFormat.tryParse(dateText), + source = source, + scanlator = null, + branch = null, + ) + } + } + + 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(var pages =)") + val json = JSONArray(script.data().substringAfter('=').substringBeforeLast(';')) + val pages = ArrayList(json.length()) + for (i in 0 until json.length()) { + val url = "https://" + domain + json.getString(i).substringAfter(":\"").substringBefore("\",") + 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/Mangaowl.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Mangaowl.kt new file mode 100644 index 00000000..3930970c --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Mangaowl.kt @@ -0,0 +1,199 @@ +package org.koitharu.kotatsu.parsers.site.en + +import kotlinx.coroutines.coroutineScope +import okhttp3.Headers +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.network.UserAgents +import org.koitharu.kotatsu.parsers.util.* +import org.koitharu.kotatsu.parsers.util.json.mapJSON +import java.text.SimpleDateFormat +import java.util.* + +@MangaSourceParser("MANGAOWL", "Mangaowl", "en") +internal class Mangaowl(context: MangaLoaderContext) : + PagedMangaParser(context, MangaSource.MANGAOWL, pageSize = 24) { + + override val sortOrders: Set = EnumSet.of( + SortOrder.POPULARITY, + SortOrder.NEWEST, + SortOrder.UPDATED, + SortOrder.RATING, + ) + + override val configKeyDomain = ConfigKey.Domain("mangaowl.to") + + 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 sort = when (sortOrder) { + SortOrder.POPULARITY -> "view_count" + SortOrder.UPDATED -> "-modified_at" + SortOrder.NEWEST -> "created_at" + SortOrder.RATING -> "rating" + else -> "modified_at" + } + val url = buildString { + append("https://") + append(domain) + when { + !query.isNullOrEmpty() -> { + append("/8-search") + append("?q=") + append(query.urlEncoded()) + append("&page=") + append(page.toString()) + } + + !tags.isNullOrEmpty() -> { + append("/8-genres/") + for (tag in tags) { + append(tag.key) + } + append("?page=") + append(page.toString()) + } + + else -> { + + append("/8-comics") + append("?page=") + append(page.toString()) + append("&ordering=") + append(sort) + } + } + } + val doc = webClient.httpGet(url).parseHtml() + return doc.select("div.manga-item.column").map { div -> + val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = href.toAbsoluteUrl(div.host ?: domain), + coverUrl = div.selectFirst("img")?.src().orEmpty(), + title = div.selectFirst("a.one-line")?.text().orEmpty(), + altTitle = null, + rating = div.select("span").last()?.text()?.toFloatOrNull()?.div(5f) ?: RATING_UNKNOWN, + tags = emptySet(), + author = null, + state = null, + source = source, + isNsfw = false, + ) + } + } + + override suspend fun getTags(): Set { + val doc = webClient.httpGet("https://$domain/8-genres").parseHtml() + return doc.select("div.genres-container span.genre-item a").mapNotNullToSet { a -> + val key = a.attr("href").substringAfterLast("/") + MangaTag( + key = key, + title = a.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("div.comic-attrs div.column.my-2:contains(Genres) a").mapNotNullToSet { a -> + MangaTag( + key = a.attr("href").removeSuffix("/").substringAfterLast('/'), + title = a.text().toTitleCase().replace(",", ""), + source = source, + ) + }, + description = doc.select("span.story-desc").html(), + state = when (doc.select("div.section-status:contains(Status) span").last()?.text()) { + "Ongoing" -> MangaState.ONGOING + "Completed" -> MangaState.FINISHED + else -> null + }, + chapters = getChapters(manga.url, doc), + ) + } + + private fun getChapters(mangaUrl: String, doc: Document): List { + + val dateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSSSS'Z'", sourceLocale) + + val script = doc.selectFirstOrThrow("script:containsData(chapters:)") + val json = + script.data().substringAfter("chapters:[").substringBeforeLast(')').substringBefore("],latest_chapter:") + .split("},") + val slug = mangaUrl.substringAfterLast("/") + + val chapter = ArrayList() + val num = 0 + json.map { t -> + if (t.contains("Chapter")) { + val id = t.substringAfter("id:").substringBefore(",created_at") + val url = "/reading/$slug/$id" + + val date = t.substringAfter("created_at:\"").substringBefore("\"") + val name = t.substringAfter("name:\"").substringBefore("\"") + chapter.add( + MangaChapter( + id = generateUid(url), + name = name, + number = num + 1, + url = url, + uploadDate = dateFormat.tryParse(date), + source = source, + scanlator = null, + branch = null, + ), + ) + } + } + + // last chapter + val id = script.data().substringAfter("Sign in\",").substringBefore(",\"").split(",").last() + val url = "/reading/$slug/$id" + val date = script.data().substringAfter("$id,\"").substringBefore("\",") + val name = script.data().substringAfter("$date\",\"").substringBefore("\",") + chapter.add( + MangaChapter( + id = generateUid(url), + name = name, + number = num + 1, + url = url, + uploadDate = dateFormat.tryParse(date), + source = source, + scanlator = null, + branch = null, + ), + ) + + return chapter + } + + override suspend fun getPages(chapter: MangaChapter): List { + val id = chapter.url.substringAfterLast("/") + + val json = webClient.httpGet("https://api.mangaowl.to/v1/chapters/$id/images?page_size=100").parseJson() + return json.getJSONArray("results").mapJSON { jo -> + MangaPage( + id = generateUid(jo.getString("image")), + preview = null, + source = chapter.source, + url = jo.getString("image"), + ) + } + } +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/TempleScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/TempleScan.kt new file mode 100644 index 00000000..1c35a50b --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/TempleScan.kt @@ -0,0 +1,133 @@ +package org.koitharu.kotatsu.parsers.site.en + +import kotlinx.coroutines.coroutineScope +import okhttp3.Headers +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.network.UserAgents +import org.koitharu.kotatsu.parsers.util.* +import java.util.* + +@MangaSourceParser("TEMPLESCAN", "TempleScan", "en") +internal class TempleScan(context: MangaLoaderContext) : + PagedMangaParser(context, MangaSource.TEMPLESCAN, pageSize = 15) { + + override val sortOrders: Set = EnumSet.of(SortOrder.NEWEST, SortOrder.UPDATED) + + override val configKeyDomain = ConfigKey.Domain("templescan.net") + + 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 url = buildString { + append("https://") + append(domain) + if (sortOrder == SortOrder.NEWEST) { + append("/comics") + append("?page=") + append(page.toString()) + } else { + if (page > 1) { + return emptyList() + } + } + } + + val doc = webClient.httpGet(url).parseHtml() + return doc.select("div.grid figure").ifEmpty { + doc.requireElementById("projectsDiv").select("figure") + }.map { div -> + val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = href.toAbsoluteUrl(div.host ?: domain), + coverUrl = div.selectFirst("img")?.src().orEmpty(), + title = div.selectFirst("figcaption")?.text().orEmpty(), + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + author = null, + state = null, + source = source, + isNsfw = false, + ) + } + } + + override suspend fun getTags(): Set = emptySet() + + override suspend fun getDetails(manga: Manga): Manga = coroutineScope { + val fullUrl = manga.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + val chaptersDeferred = getChapters(doc) + manga.copy( + description = doc.requireElementById("section-sinopsis").html(), + chapters = chaptersDeferred, + isNsfw = false, + ) + } + + private fun getChapters(doc: Document): List { + return doc.body().select("div.grid-capitulos div.contenedor-capitulo-miniatura") + .mapChapters(reversed = true) { i, div -> + val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href") + val date = parseUploadDate(div.selectFirstOrThrow("time").text()) + MangaChapter( + id = generateUid(href), + name = div.requireElementById("name").text(), + number = i + 1, + url = href, + uploadDate = date, + source = source, + scanlator = null, + branch = null, + ) + } + } + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + return doc.select("main.contenedor-imagen img").map { url -> + val img = url.src()?.toRelativeUrl(domain) ?: url.parseFailed("Image src not found") + MangaPage( + id = generateUid(img), + url = img, + preview = null, + source = source, + ) + } + } + + private fun parseUploadDate(timeStr: String?): Long { + timeStr ?: return 0 + val timeWords = timeStr.split(' ') + if (timeWords.size != 3) return 0 + val timeWord = timeWords[1] + val timeAmount = timeWords[0].toIntOrNull() ?: return 0 + val timeUnit = when (timeWord) { + "minute", "minutes" -> Calendar.MINUTE + "hour", "hours" -> Calendar.HOUR + "day", "days" -> Calendar.DAY_OF_YEAR + "week", "weeks" -> Calendar.WEEK_OF_YEAR + "month", "months" -> Calendar.MONTH + "year", "years" -> Calendar.YEAR + else -> return 0 + } + val cal = Calendar.getInstance() + cal.add(timeUnit, -timeAmount) + return cal.time.time + } +} 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 f8892de1..cbf2f661 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 @@ -116,7 +116,7 @@ internal class BentomangaParser(context: MangaLoaderContext) : PagedMangaParser( coroutineScope { val result = ArrayList(parseChapters(root)) result.ensureCapacity(result.size * max) - (2..max).map { i -> + (1..max).map { i -> async { loadChapters(mangaUrl, i) } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/FuryoSociety.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/FuryoSociety.kt new file mode 100644 index 00000000..13a41710 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/FuryoSociety.kt @@ -0,0 +1,158 @@ +package org.koitharu.kotatsu.parsers.site.fr + +import kotlinx.coroutines.coroutineScope +import okhttp3.Headers +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.network.UserAgents +import org.koitharu.kotatsu.parsers.util.* +import java.text.DateFormat +import java.text.SimpleDateFormat +import java.util.* + +@MangaSourceParser("FURYOSOCIETY", "Furyo Society", "fr") +internal class FuryoSociety(context: MangaLoaderContext) : + PagedMangaParser(context, MangaSource.FURYOSOCIETY, 0) { + + override val sortOrders: Set = EnumSet.of(SortOrder.ALPHABETICAL, SortOrder.UPDATED) + + override val configKeyDomain = ConfigKey.Domain("furyosociety.com") + + override val headers: Headers = Headers.Builder() + .add("User-Agent", UserAgents.CHROME_DESKTOP) + .build() + + override suspend fun getFavicons(): Favicons { + return Favicons( + listOf( + Favicon("https://$domain/fs_favicon/favicon-32x32.png", 32, null), + ), + domain, + ) + } + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + val url = buildString { + append("https://") + append(domain) + if (page == 1) { + if (sortOrder == SortOrder.ALPHABETICAL) { + append("/mangas") + } + } else { + return emptyList() + } + } + + val doc = webClient.httpGet(url).parseHtml() + return doc.select("div.fs-card-container div.grid-item-container").ifEmpty { + doc.select("div.container-tight.latest table tr") + }.map { div -> + val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + url = href, + publicUrl = href.toAbsoluteUrl(div.host ?: domain), + coverUrl = div.selectFirst("img")?.src().orEmpty(), + title = (div.selectFirst("div.media-body") ?: div.selectFirst("a"))?.text().orEmpty(), + altTitle = null, + rating = RATING_UNKNOWN, + tags = emptySet(), + author = null, + state = null, + source = source, + isNsfw = false, + ) + } + } + + + override suspend fun getTags(): Set = emptySet() + + + override suspend fun getDetails(manga: Manga): Manga = coroutineScope { + val fullUrl = manga.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + val chaptersDeferred = getChapters(doc) + manga.copy( + description = doc.selectFirstOrThrow("div.fs-comic-description").html(), + chapters = chaptersDeferred, + isNsfw = doc.selectFirst(".adult-text") != null, + ) + } + + + private fun getChapters(doc: Document): List { + return doc.body().select("div.list.fs-chapter-list div.element").mapChapters(reversed = true) { i, div -> + val a = div.selectFirstOrThrow("div.title a") + val href = a.attrAsRelativeUrl("href") + val dateFormat = SimpleDateFormat("dd/MM/yyyy", sourceLocale) + val dateText = div.selectFirstOrThrow("div.meta_r").text().replace("Hier", "1 jour") + MangaChapter( + id = generateUid(href), + name = div.selectFirstOrThrow("div.title").text() + " : " + div.selectFirstOrThrow("div.name").text(), + number = i + 1, + url = href, + uploadDate = parseChapterDate( + dateFormat, + dateText, + ), + source = source, + scanlator = null, + branch = null, + ) + } + } + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + return doc.select("div.main-img img").map { url -> + val img = url.src()?.toRelativeUrl(domain) ?: url.parseFailed("Image src not found") + MangaPage( + id = generateUid(img), + url = img, + preview = null, + source = source, + ) + } + } + + private fun parseChapterDate(dateFormat: DateFormat, date: String?): Long { + val d = date?.lowercase() ?: return 0 + return when { + d.startsWith("il y a") || // Handle translated 'ago' in French. + d.endsWith(" an") || d.endsWith(" ans") || + d.endsWith(" mois") || + d.endsWith(" jour") || d.endsWith(" jours") || + d.endsWith(" heure") || d.endsWith(" heures") || + d.endsWith(" seconde") || d.endsWith(" secondes") || + d.endsWith(" minute") || d.endsWith(" minutes") -> parseRelativeDate(date) + + else -> dateFormat.tryParse(date) + } + } + + private fun parseRelativeDate(date: String): Long { + val number = Regex("""(\d+)""").find(date)?.value?.toIntOrNull() ?: return 0 + val cal = Calendar.getInstance() + return when { + WordSet("seconde", "secondes").anyWordIn(date) -> cal.apply { add(Calendar.SECOND, -number) }.timeInMillis + WordSet("minute", "minutes").anyWordIn(date) -> cal.apply { add(Calendar.MINUTE, -number) }.timeInMillis + WordSet("heure", "heures").anyWordIn(date) -> cal.apply { add(Calendar.HOUR, -number) }.timeInMillis + WordSet("jour", "jours").anyWordIn(date) -> cal.apply { add(Calendar.DAY_OF_MONTH, -number) }.timeInMillis + WordSet("mois").anyWordIn(date) -> cal.apply { add(Calendar.MONTH, -number) }.timeInMillis + WordSet("an", "ans").anyWordIn(date) -> cal.apply { add(Calendar.YEAR, -number) }.timeInMillis + else -> 0 + } + } +} 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 eecf840a..3867e32c 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 @@ -97,6 +97,7 @@ internal abstract class MadaraParser( @JvmField protected val finished: Set = hashSetOf( "Completed", + "Complete", "Completo", "Complété", "Fini", @@ -108,6 +109,7 @@ internal abstract class MadaraParser( "Hoàn Thành", "مكتملة", "Завершено", + "Завершен", "Finished", "Finalizado", "Completata", @@ -211,7 +213,8 @@ internal abstract class MadaraParser( url = href, publicUrl = href.toAbsoluteUrl(div.host ?: domain), coverUrl = div.selectFirst("img")?.src().orEmpty(), - title = (summary?.selectFirst("h3") ?: summary?.selectFirst("h4"))?.text().orEmpty(), + title = (summary?.selectFirst("h3") ?: summary?.selectFirst("h4") + ?: div.selectFirst(".manga-name"))?.text().orEmpty(), altTitle = null, rating = div.selectFirst("span.total_votes")?.ownText()?.toFloatOrNull()?.div(5f) ?: -1f, tags = summary?.selectFirst(".mg_genres")?.select("a")?.mapNotNullToSet { a -> @@ -384,6 +387,7 @@ internal abstract class MadaraParser( } } + protected open val selectBodyPage = "div.main-col-inner div.reading-content" protected open val selectPage = "div.page-break" override suspend fun getPages(chapter: MangaChapter): List { @@ -392,7 +396,7 @@ internal abstract class MadaraParser( val chapterProtector = doc.getElementById("chapter-protector-data") if (chapterProtector == null) { - val root = doc.body().selectFirstOrThrow("div.main-col-inner").selectFirstOrThrow("div.reading-content") + val root = doc.body().selectFirstOrThrow(selectBodyPage) return root.select(selectPage).map { div -> val img = div.selectFirstOrThrow("img") val url = img.src()?.toRelativeUrl(domain) ?: div.parseFailed("Image src not found") 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 7bbc7561..5adb2452 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 @@ -9,6 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("AZORANOV", "Azoranov", "ar") internal class Azoranov(context: MangaLoaderContext) : MadaraParser(context, MangaSource.AZORANOV, "azoranov.com", pageSize = 10) { - - override val tagPrefix = "novel-genre/" + override val tagPrefix = "series-genre/" + override val listUrl = "series/" } 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 b764aa80..93fa8533 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 @@ -12,4 +12,5 @@ internal class GateManga(context: MangaLoaderContext) : override val postreq = true override val datePattern = "d MMMM، yyyy" + override val listUrl = "ar/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/WebtoonEmpire.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/WebtoonEmpire.kt index feba39c2..94fd2aff 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/WebtoonEmpire.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/WebtoonEmpire.kt @@ -9,5 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class WebtoonEmpire(context: MangaLoaderContext) : MadaraParser(context, MangaSource.WEBTOONEMPIRE, "webtoonempire.org", pageSize = 10) { + override val listUrl = "webtoon/" override val datePattern = "d MMMM yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BestManhuaCom.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BestManhuaCom.kt new file mode 100644 index 00000000..5730c272 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BestManhuaCom.kt @@ -0,0 +1,125 @@ +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.Manga +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.model.MangaTag +import org.koitharu.kotatsu.parsers.model.SortOrder +import org.koitharu.kotatsu.parsers.site.madara.MadaraParser +import org.koitharu.kotatsu.parsers.util.* + +@MangaSourceParser("BESTMANHUACOM", "BestManhua Com", "en") +internal class BestManhuaCom(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.BESTMANHUACOM, "bestmanhua.com", 20) { + override val datePattern = "dd MMMM yyyy" + override val tagPrefix = "genres/" + override val listUrl = "all-manga/" + override val withoutAjax = true + override val selectDesc = "div.dsct" + override val selectTestAsync = "div.panel-manga-chapter" + override val selectDate = "span.chapter-time" + override val selectChapter = "li.a-h" + override val selectBodyPage = "div.manga-content div.read-content" + override val selectPage = "div.image-placeholder" + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + + val url = buildString { + append("https://") + append(domain) + val pages = page + 1 + when { + !query.isNullOrEmpty() -> { + append("/page/") + append(pages.toString()) + append("/?s=") + append(query.urlEncoded()) + append("&post_type=wp-manga&") + } + + !tags.isNullOrEmpty() -> { + append("/$tagPrefix") + for (tag in tags) { + append(tag.key) + } + append("/") + append(pages.toString()) + append("?") + } + + else -> { + append("/$listUrl") + append(pages.toString()) + append("?") + } + } + append("sort=") + when (sortOrder) { + SortOrder.POPULARITY -> append("most-viewd") + SortOrder.UPDATED -> append("latest-updated") + SortOrder.NEWEST -> append("release-date") + SortOrder.ALPHABETICAL -> append("name-az") + else -> append("latest") + } + } + val doc = webClient.httpGet(url).parseHtml() + + return doc.select("div.page-item").map { div -> + val href = div.selectFirst("a")?.attrAsRelativeUrlOrNull("href") ?: div.parseFailed("Link not found") + val summary = div.selectFirstOrThrow(".bigor-manga") + Manga( + id = generateUid(href), + url = href, + publicUrl = href.toAbsoluteUrl(div.host ?: domain), + coverUrl = div.selectFirst("img")?.src().orEmpty(), + title = summary.selectFirst("h3")?.text().orEmpty(), + altTitle = null, + rating = div.selectFirstOrThrow("div.item-rate span").ownText().toFloatOrNull()?.div(5f) ?: -1f, + tags = emptySet(), + author = null, + state = null, + source = source, + isNsfw = isNsfwSource, + ) + } + } + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + + val chapterId = + doc.selectFirst("script:containsData(chapter_id = )")?.toString()?.substringAfter("chapter_id = ") + ?.substringBefore(",") + + val json = + webClient.httpGet("https://$domain/ajax/image/list/chap/$chapterId?mode=vertical&quality=high").parseJson() + + val html = json.getString("html").split("/div>") + + val pages = ArrayList() + + html.map { t -> + if (t.contains("data-src=")) { + val url = t.substringAfter("data-src=\"").substringBefore("\"") + 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/madara/en/BoysLove.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BoysLove.kt index bd4d2696..029f937b 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,6 @@ 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 } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/DarkScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/DarkScans.kt index 8b211a5e..3d860d18 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/DarkScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/DarkScans.kt @@ -7,4 +7,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("DARK_SCANS", "DarkScans", "en") internal class DarkScans(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.DARK_SCANS, "darkscans.com", 18) + MadaraParser(context, MangaSource.DARK_SCANS, "darkscans.com", 18) { + override val listUrl = "mangas/" + override val tagPrefix = "mangas-genre/" +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/DrakeScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/DrakeScans.kt index 8f2fd679..6818bb56 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/DrakeScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/DrakeScans.kt @@ -11,4 +11,5 @@ internal class DrakeScans(context: MangaLoaderContext) : override val datePattern = "dd/MM/yyyy" override val tagPrefix = "series-genre/" + override val listUrl = "series/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/FreeWebtoonCoins.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/FreeWebtoonCoins.kt index af122646..a8574c2d 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/FreeWebtoonCoins.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/FreeWebtoonCoins.kt @@ -10,4 +10,5 @@ internal class FreeWebtoonCoins(context: MangaLoaderContext) : MadaraParser(context, MangaSource.FREEWEBTOONCOINS, "freewebtooncoins.com") { override val tagPrefix = "webtoon-genre/" + override val listUrl = "webtoon/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/TempleScan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/GourmetScans.kt similarity index 55% rename from src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/TempleScan.kt rename to src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/GourmetScans.kt index f12d5c87..3f1db1f3 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/TempleScan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/GourmetScans.kt @@ -5,10 +5,11 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -@MangaSourceParser("TEMPLESCAN", "TempleScan", "en") -internal class TempleScan(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.TEMPLESCAN, "templescan.net") { +@MangaSourceParser("GOURMETSCANS", "Gourmet Scans", "en") +internal class GourmetScans(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.GOURMETSCANS, "gourmetscans.net") { - override val datePattern = "dd.MM.yyyy" + override val listUrl = "project/" override val tagPrefix = "genre/" + override val stylepage = "" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Grabber.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Grabber.kt index 5f4b9d5a..c7f2c289 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Grabber.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Grabber.kt @@ -10,5 +10,6 @@ internal class Grabber(context: MangaLoaderContext) : MadaraParser(context, MangaSource.GRABBER, "grabber.zone", 20) { override val tagPrefix = "type/" + override val listUrl = "comics/" override val datePattern = "dd.MM.yyyy" } 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 de308796..3b4d213c 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 @@ -11,7 +11,7 @@ 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 - } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Hentai4Free.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Hentai4Free.kt index d897ee41..3943568c 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Hentai4Free.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Hentai4Free.kt @@ -4,14 +4,106 @@ 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.Manga import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.model.MangaState +import org.koitharu.kotatsu.parsers.model.MangaTag +import org.koitharu.kotatsu.parsers.model.SortOrder import org.koitharu.kotatsu.parsers.site.madara.MadaraParser +import org.koitharu.kotatsu.parsers.util.* @MangaSourceParser("HENTAI_4FREE", "Hentai4Free", "en", ContentType.HENTAI) internal class Hentai4Free(context: MangaLoaderContext) : MadaraParser(context, MangaSource.HENTAI_4FREE, "hentai4free.net", pageSize = 24) { override val tagPrefix = "hentai-tag/" + override val listUrl = "" + override val withoutAjax = true override val datePattern = "MMMM dd, yyyy" + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + val url = buildString { + append("https://") + append(domain) + val pages = page + 1 + when { + !query.isNullOrEmpty() -> { + append("/page/") + append(pages.toString()) + append("/?s=") + append(query.urlEncoded()) + append("&post_type=wp-manga&") + } + + !tags.isNullOrEmpty() -> { + append("/$tagPrefix") + for (tag in tags) { + append(tag.key) + } + append("/") + if (pages > 1) { + append("page/") + append(pages.toString()) + } + } + + else -> { + + if (pages > 1) { + append("/page/") + append(pages.toString()) + } + append("/?m_orderby=") + when (sortOrder) { + SortOrder.POPULARITY -> append("views") + SortOrder.UPDATED -> append("latest") + SortOrder.NEWEST -> append("new-manga") + SortOrder.ALPHABETICAL -> append("alphabet") + else -> append("latest") + } + } + } + + } + val doc = webClient.httpGet(url).parseHtml() + + return doc.select("div.row.c-tabs-item__content").ifEmpty { + doc.select("div.page-item-detail") + }.map { div -> + val href = div.selectFirst("a")?.attrAsRelativeUrlOrNull("href") ?: div.parseFailed("Link not found") + val summary = div.selectFirst(".tab-summary") ?: div.selectFirst(".item-summary") + Manga( + id = generateUid(href), + url = href, + publicUrl = href.toAbsoluteUrl(div.host ?: domain), + coverUrl = div.selectFirst("img")?.src().orEmpty(), + title = (summary?.selectFirst("h3") ?: summary?.selectFirst("h4") + ?: div.selectFirst(".manga-name"))?.text().orEmpty(), + altTitle = null, + rating = div.selectFirst("span.total_votes")?.ownText()?.toFloatOrNull()?.div(5f) ?: -1f, + tags = summary?.selectFirst(".mg_genres")?.select("a")?.mapNotNullToSet { a -> + MangaTag( + key = a.attr("href").removeSuffix('/').substringAfterLast('/'), + title = a.text().ifEmpty { return@mapNotNullToSet null }.toTitleCase(), + source = source, + ) + }.orEmpty(), + author = summary?.selectFirst(".mg_author")?.selectFirst("a")?.ownText(), + state = when (summary?.selectFirst(".mg_status")?.selectFirst(".summary-content")?.ownText() + ?.lowercase()) { + in ongoing -> MangaState.ONGOING + in finished -> MangaState.FINISHED + else -> null + }, + source = source, + isNsfw = isNsfwSource, + ) + } + } } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ImmortalUpdates.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ImmortalUpdates.kt index 2996fa15..668d94cb 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ImmortalUpdates.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ImmortalUpdates.kt @@ -7,4 +7,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("IMMORTALUPDATES", "Immortal Updates", "en") internal class ImmortalUpdates(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.IMMORTALUPDATES, "immortalupdates.com") + MadaraParser(context, MangaSource.IMMORTALUPDATES, "immortalupdates.com") { + override val listUrl = "mangas/" +} 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 1d01457b..71bcb666 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 @@ -14,6 +14,7 @@ internal class IsekaiScan(context: MangaLoaderContext) : MadaraParser(context, MangaSource.ISEKAISCAN, "isekaiscan.top", 16) { override val tagPrefix = "mangas/" + override val listUrl = "latest-manga/" override val datePattern = "MMMM d, HH:mm" override val sortOrders: Set = EnumSet.of( @@ -67,6 +68,9 @@ internal class IsekaiScan(context: MangaLoaderContext) : } } val doc = webClient.httpGet(url).parseHtml() + if (url != "ursdvsdvl") { + throw Exception(doc.toString()) + } return doc.select("div.row.c-tabs-item__content").ifEmpty { doc.select("div.page-item-detail.manga") }.map { div -> diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/KissManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/KissManga.kt index 48a9d0eb..9e4112f4 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/KissManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/KissManga.kt @@ -8,4 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("KISSMANGA", "KissManga", "en") internal class KissManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.KISSMANGA, "kissmanga.in") { override val datePattern = "MMMM dd, yyyy" + override val listUrl = "mangalist/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/LilyManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/LilyManga.kt index f702070f..eae1ad34 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/LilyManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/LilyManga.kt @@ -11,5 +11,6 @@ internal class LilyManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.LILYMANGA, "lilymanga.net") { override val tagPrefix = "ys-genre/" + override val listUrl = "ys/" override val datePattern = "yyyy-MM-dd" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaBaz.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaBaz.kt index 0b35d889..ae63355c 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaBaz.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaBaz.kt @@ -7,4 +7,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGABAZ", "MangaBaz", "en") internal class MangaBaz(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.MANGABAZ, "mangabaz.net") + MadaraParser(context, MangaSource.MANGABAZ, "mangabaz.net") { + override val listUrl = "all-series/" + override val tagPrefix = "mangas-genre/" +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDistrict.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDistrict.kt index b50b2ea2..0aeb1b27 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDistrict.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDistrict.kt @@ -17,7 +17,6 @@ internal class MangaDistrict(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGA_DISTRICT, "mangadistrict.com", pageSize = 30) { override val tagPrefix = "publication-genre/" - override val datePattern = "MMM dd,yyyy" override suspend fun getChapters(manga: Manga, doc: Document): List { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaHentai.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaHentai.kt index de08b995..06695f90 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaHentai.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaHentai.kt @@ -11,4 +11,5 @@ internal class MangaHentai(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAHENTAI, "mangahentai.me", 20) { override val tagPrefix = "manga-hentai-genre/" + override val listUrl = "manga-hentai/" } 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 289b66a4..07c0c441 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 @@ -11,6 +11,6 @@ internal class MangaLeveling(context: MangaLoaderContext) : 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/Manhuamix.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuamix.kt index d31837e9..f041e1a7 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuamix.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuamix.kt @@ -10,4 +10,5 @@ internal class Manhuamix(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHUAMIX, "manhuamix.com", 20) { override val tagPrefix = "manhua-genre/" + override val listUrl = "manhua/" } 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 2c8af0e8..d47282f3 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 @@ -11,5 +11,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class Manhuasy(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHUASY, "www.manhuasy.com") { + override val listUrl = "manhua/" override val tagPrefix = "manhua-genre/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaFull.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaFull.kt index 9e9da4d9..9560ac5f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaFull.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaFull.kt @@ -9,5 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class ManhwaFull(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHWAFULL, "manhwafull.com") { + override val listUrl = "manga-all-manhwa/" override val datePattern = "MM/dd/yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaHentai.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaHentai.kt index 4393f8b2..fed6d244 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaHentai.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaHentai.kt @@ -11,4 +11,5 @@ internal class ManhwaHentai(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANHWAHENTAI, "manhwahentai.me", 20) { override val tagPrefix = "webtoon-genre/" + override val listUrl = "webtoon/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyToon.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyToon.kt index 36fc11f7..c1b6433d 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyToon.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyToon.kt @@ -8,4 +8,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANYTOON", "Many Toon", "en", ContentType.HENTAI) internal class ManyToon(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.MANYTOON, "manytoon.com", 20) + MadaraParser(context, MangaSource.MANYTOON, "manytoon.com", 20) { + override val listUrl = "comic/" +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyToonMe.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyToonMe.kt index d26d6b6e..1afaceda 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyToonMe.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyToonMe.kt @@ -8,4 +8,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANYTOONME", "Many Toon Me", "en", ContentType.HENTAI) internal class ManyToonMe(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.MANYTOONME, "manytoon.me", 20) + MadaraParser(context, MangaSource.MANYTOONME, "manytoon.me", 20) { + override val listUrl = "manhwa/" + override val tagPrefix = "manhwa-genre/" +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ReadFreeComics.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ReadFreeComics.kt index 6b479814..55a973ed 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ReadFreeComics.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ReadFreeComics.kt @@ -11,4 +11,5 @@ internal class ReadFreeComics(context: MangaLoaderContext) : MadaraParser(context, MangaSource.READFREECOMICS, "readfreecomics.com") { override val tagPrefix = "webtoon-comic-genre/" + override val listUrl = "webtoon-comic/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/SleepyTranslations.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/SleepyTranslations.kt index db42b47b..2830d6cc 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/SleepyTranslations.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/SleepyTranslations.kt @@ -10,5 +10,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class SleepyTranslations(context: MangaLoaderContext) : MadaraParser(context, MangaSource.SLEEPYTRANSLATIONS, "sleepytranslations.com", 16) { + override val listUrl = "series/" override val tagPrefix = "genre/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Toonily.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Toonily.kt index 7e80b951..70c18e75 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Toonily.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Toonily.kt @@ -9,6 +9,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class Toonily(context: MangaLoaderContext) : MadaraParser(context, MangaSource.TOONILY, "toonily.com", pageSize = 18) { + override val listUrl = "webtoon/" override val tagPrefix = "webtoon-genre/" override val datePattern = "MMMM dd, yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/WebtoonXyz.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/WebtoonXyz.kt index bd9ee463..70c3d74e 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/WebtoonXyz.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/WebtoonXyz.kt @@ -12,5 +12,6 @@ internal class WebtoonXyz(context: MangaLoaderContext) : MadaraParser(context, MangaSource.WEBTOONXYZ, "www.webtoon.xyz", 20) { override val tagPrefix = "webtoon-genre/" + override val listUrl = "read/" override val datePattern = "d MMM yyyy" } 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 0903d693..b8ca49bb 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,6 @@ 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 } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Woopread.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Woopread.kt index 207eebc1..9e57ab78 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Woopread.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Woopread.kt @@ -9,5 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class Woopread(context: MangaLoaderContext) : MadaraParser(context, MangaSource.WOOPREAD, "woopread.com", 10) { + override val listUrl = "series/" override val tagPrefix = "series-genres/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ZandynoFansub.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ZandynoFansub.kt index 58d813c2..55c47edc 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ZandynoFansub.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ZandynoFansub.kt @@ -9,5 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class ZandynoFansub(context: MangaLoaderContext) : MadaraParser(context, MangaSource.ZANDYNOFANSUB, "zandynofansub.aishiteru.org", 20) { + override val listUrl = "series/" override val datePattern = "dd.MM.yyyy" } 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/AiyuMangaScanlation.kt index 862d43eb..baadc6d5 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/AiyuMangaScanlation.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("AIYUMANGASCANLATION", "AiyuMangaScanlation", "es") +@MangaSourceParser("AIYUMANGASCANLATION", "Aiyu Manga", "es") internal class AiyuMangaScanlation(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.AIYUMANGASCANLATION, "aiyumangascanlation.com") { - + MadaraParser(context, MangaSource.AIYUMANGASCANLATION, "aiyumanga.com") { override val datePattern = "MM/dd/yyyy" + override val listUrl = "series/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/DoujinHentaiNet.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/DoujinHentaiNet.kt new file mode 100644 index 00000000..20460244 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/DoujinHentaiNet.kt @@ -0,0 +1,40 @@ +package org.koitharu.kotatsu.parsers.site.madara.es + +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.* +import java.util.Locale + +@MangaSourceParser("DOUJIN_HENTAI_NET", "Doujin Hentai Net", "es", ContentType.HENTAI) +internal class DoujinHentaiNet(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.DOUJIN_HENTAI_NET, "doujinhentai.net", 18) { + override val datePattern = "dd MMM. yyyy" + override val sourceLocale: Locale = Locale.ENGLISH + override val listUrl = "lista-manga-hentai/" + override val tagPrefix = "lista-manga-hentai/category/" + override val selectTestAsync = "div.listing-chapters_wrap" + override val selectChapter = "li.wp-manga-chapter:contains(Capitulo)" + override val selectPage = "div#all img" + + + override suspend fun getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + return doc.select(selectPage).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/madara/es/MangaMundoDrama.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/MangaMundoDrama.kt index 0f699ba6..69117416 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/MangaMundoDrama.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/MangaMundoDrama.kt @@ -7,4 +7,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("MANGAMUNDODRAMA", "Manga Mundo Drama", "es") internal class MangaMundoDrama(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.MANGAMUNDODRAMA, "inmortalscan.com") + MadaraParser(context, MangaSource.MANGAMUNDODRAMA, "manga.mundodrama.site") { + override val listUrl = "mg/" +} 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 20b591cd..435145fc 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 @@ -10,6 +10,6 @@ internal class RagnarokScan(context: MangaLoaderContext) : MadaraParser(context, MangaSource.RAGNAROKSCAN, "ragnarokscan.com") { override val stylepage = "" + override val listUrl = "series/" override val tagPrefix = "genero/" - } 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 6d76dcb2..37397874 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 @@ -7,4 +7,4 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser @MangaSourceParser("FRSCAN", "FrScan", "fr") internal class FrScan(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.FRSCAN, "fr-scan.com") + MadaraParser(context, MangaSource.FRSCAN, "fr-scan.cc") diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/KaratcamScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/KaratcamScans.kt index 07a4f56e..74548775 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/KaratcamScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/KaratcamScans.kt @@ -10,5 +10,6 @@ internal class KaratcamScans(context: MangaLoaderContext) : MadaraParser(context, MangaSource.KARATCAMSCANS, "karatcam-scans.fr") { override val tagPrefix = "webtoon-genre/" + override val listUrl = "webtoon/" override val datePattern = "dd/MM/yyyy" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/MangasOrigines.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/MangasOrigines.kt index 47a24b71..56c2de62 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/MangasOrigines.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/MangasOrigines.kt @@ -10,4 +10,6 @@ internal class MangasOrigines(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGASORIGINES, "mangas-origines.fr") { override val datePattern = "dd/MM/yyyy" + override val tagPrefix = "manga-genres/" + override val listUrl = "oeuvre/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/ToonFr.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/ToonFr.kt index 0521a82d..acab05ea 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/ToonFr.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/ToonFr.kt @@ -15,6 +15,7 @@ internal class ToonFr(context: MangaLoaderContext) : MadaraParser(context, MangaSource.TOONFR, "toonfr.com") { override val tagPrefix = "webtoon-genre/" + override val listUrl = "webtoon/" override val datePattern = "MMM d" override suspend fun loadChapters(mangaUrl: String, document: Document): List { 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 new file mode 100644 index 00000000..fc2644d6 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/GourmetScansId.kt @@ -0,0 +1,15 @@ +package org.koitharu.kotatsu.parsers.site.madara.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.madara.MadaraParser + +@MangaSourceParser("GOURMETSCANS_ID", "Gourmet Scans Id", "id") +internal class GourmetScansId(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.GOURMETSCANS_ID, "id.gourmetscans.net") { + + override val listUrl = "project/" + override val tagPrefix = "genre/" + 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 042c0b57..c6649665 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 @@ -11,6 +11,7 @@ internal class Komiksay(context: MangaLoaderContext) : MadaraParser(context, MangaSource.KOMIKSA, "komiksay.site") { override val tagPrefix = "komik-genre/" + override val listUrl = "komik/" override val datePattern = "MMMM d" override val sourceLocale: Locale = Locale.ENGLISH } 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 45103c9c..4551cff7 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 @@ -11,6 +11,7 @@ internal class Mgkomik(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MGKOMIK, "mgkomik.com", 20) { override val tagPrefix = "genres/" + override val listUrl = "komik/" override val datePattern = "dd MMM yy" override val sourceLocale: Locale = Locale.ENGLISH } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/PojokManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/PojokManga.kt index 0d41b6b3..1f7954a5 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/PojokManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/PojokManga.kt @@ -11,6 +11,7 @@ internal class PojokManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.POJOKMANGA, "pojokmanga.net") { override val tagPrefix = "komik-genre/" + override val listUrl = "komik/" override val datePattern = "MMM d, yyyy" override val sourceLocale: Locale = Locale.ENGLISH } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Shinigami.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Shinigami.kt index e2bc1f79..36104878 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Shinigami.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Shinigami.kt @@ -11,5 +11,6 @@ internal class Shinigami(context: MangaLoaderContext) : MadaraParser(context, MangaSource.SHINIGAMI, "shinigami.id", 10) { override val tagPrefix = "genre/" + override val listUrl = "series/" override val sourceLocale: Locale = Locale.ENGLISH } 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 new file mode 100644 index 00000000..14189fce --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/WickedWitchScan.kt @@ -0,0 +1,13 @@ +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("WICKEDWITCHSCAN", "WickedWitch Scan", "pt") +internal class WickedWitchScan(context: MangaLoaderContext) : + MadaraParser(context, MangaSource.WICKEDWITCHSCAN, "wickedwitchscan.com", pageSize = 10) { + override val postreq = true +} 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/YugenMangas.kt index 42a41ada..e39b6652 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/YugenMangas.kt @@ -8,4 +8,6 @@ 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) + MadaraParser(context, MangaSource.YUGENMANGAS, "yugenmangas.com.br", 10) { + override val listUrl = "series/" +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/Mangazavr.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/Mangazavr.kt index 5c257473..cfc09aee 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/Mangazavr.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/Mangazavr.kt @@ -12,5 +12,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser internal class Mangazavr(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MANGAZAVR, "mangazavr.ru") { + override val listUrl = "/?s=&post_type=wp-manga" override val datePattern = "dd.MM.yyyy" } 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 116d9bc4..2b665467 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 @@ -13,7 +13,6 @@ internal class Cizgiromanarsivi(context: MangaLoaderContext) : 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/DiamondFansub.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/DiamondFansub.kt index d2a324a3..d233dbdf 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/DiamondFansub.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/DiamondFansub.kt @@ -12,5 +12,6 @@ internal class DiamondFansub(context: MangaLoaderContext) : MadaraParser(context, MangaSource.DIAMONDFANSUB, "diamondfansub.com", 10) { override val datePattern = "d MMMM" + override val listUrl = "seri/" override val tagPrefix = "seri-turu/" } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Mangabilgini.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Mangabilgini.kt deleted file mode 100644 index 556861f9..00000000 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Mangabilgini.kt +++ /dev/null @@ -1,17 +0,0 @@ -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("MANGABILGINI", "Mangabilgini", "tr") -internal class Mangabilgini(context: MangaLoaderContext) : - MadaraParser(context, MangaSource.MANGABILGINI, "mangabilgini.com", 44) { - - override val selectDesc = "div.ozet__icerik" - override val postreq = true - override val datePattern = "d MMMM yyyy" -} 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 6dfb67dd..48c661e7 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 @@ -5,7 +5,6 @@ import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock import org.json.JSONObject import org.jsoup.nodes.Document -import org.jsoup.nodes.Element import org.koitharu.kotatsu.parsers.MangaLoaderContext import org.koitharu.kotatsu.parsers.PagedMangaParser import org.koitharu.kotatsu.parsers.config.ConfigKey @@ -126,8 +125,8 @@ internal abstract class MangaReaderParser( ?: docs.selectFirst(".tsinfo div:contains(Durum)")?.lastElementChild()?.text() val nsfw = docs.selectFirst(".restrictcontainer") != null - || docs.selectFirst(".info-right .alr") != null - || docs.selectFirst(".postbody .alr") != null + || docs.selectFirst(".info-right .alr") != null + || docs.selectFirst(".postbody .alr") != null return manga.copy( description = docs.selectFirst("div.entry-content")?.text(), @@ -193,6 +192,7 @@ internal abstract class MangaReaderParser( protected open val selectMangalist = ".postbody .listupd .bs .bsx" protected open val selectMangaListImg = "img.ts-post-image" + protected open val selectMangaListTitle = "div.tt" protected open fun parseMangaList(docs: Document): List { return docs.select(selectMangalist).mapNotNull { @@ -204,12 +204,12 @@ internal abstract class MangaReaderParser( Manga( id = generateUid(relativeUrl), url = relativeUrl, - title = a.attr("title"), + title = it.selectFirstOrThrow(selectMangaListTitle).text() ?: a.attr("title"), altTitle = null, publicUrl = a.attrAsAbsoluteUrl("href"), rating = rating, isNsfw = isNsfwSource, - coverUrl = it.selectFirst(selectMangaListImg)?.imageUrl().orEmpty(), + coverUrl = it.selectFirst(selectMangaListImg)?.src().orEmpty(), tags = emptySet(), state = null, author = null, @@ -229,7 +229,7 @@ internal abstract class MangaReaderParser( val test = docs.select("script:containsData(ts_reader)") if (test.isNullOrEmpty() and !encodedSrc) { return docs.select(selectPage).map { img -> - val url = img.imageUrl() + val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found") MangaPage( id = generateUid(url), url = url, @@ -307,10 +307,5 @@ internal abstract class MangaReaderParser( return@withLock tagMap } - protected open fun Element.imageUrl(): String { - return attrAsAbsoluteUrlOrNull("src") - ?: attrAsAbsoluteUrlOrNull("data-src") - ?: attrAsAbsoluteUrlOrNull("data-cfsrc") - ?: "" - } + } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/SwaTeam.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/SwaTeam.kt index b0e8b1a6..f370055f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/SwaTeam.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/SwaTeam.kt @@ -16,7 +16,6 @@ internal class SwaTeam(context: MangaLoaderContext) : override val selectMangalist = ".listupd .bs .bsx" override val selectMangaListImg = "img" - // Tag doesn't work on manga page ( it comes from website ) override suspend fun getListPage( page: Int, query: String?, @@ -112,21 +111,15 @@ internal class SwaTeam(context: MangaLoaderContext) : val author = docs.selectFirst("span.author i")?.text() val nsfw = docs.selectFirst(".restrictcontainer") != null - || docs.selectFirst(".info-right .alr") != null - || docs.selectFirst(".postbody .alr") != null + || docs.selectFirst(".info-right .alr") != null + || docs.selectFirst(".postbody .alr") != null return manga.copy( description = docs.selectFirst("span.desc")?.html(), state = mangaState, author = author, isNsfw = manga.isNsfw || nsfw, - tags = docs.select("div.spe a[rel*=tag]").mapToSet { a -> - MangaTag( - key = a.attr("href").removeSuffix("/").substringAfterLast('/'), - title = a.text().toTitleCase(), - source = source, - ) - }, + tags = emptySet(), chapters = chapters, ) } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/BabelToon.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/BabelToon.kt index 55babd92..3c2cc379 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/BabelToon.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/BabelToon.kt @@ -41,7 +41,7 @@ internal class BabelToon(context: MangaLoaderContext) : val docs = webClient.httpGet(chapterUrl).parseHtml() return docs.select("div.epcontent img").map { img -> - val url = img.imageUrl() + 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/mangareader/en/PeaceScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/PeaceScans.kt new file mode 100644 index 00000000..ca2311bb --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/PeaceScans.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("PEACESCANS", "PeaceScans", "en") +internal class PeaceScans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.PEACESCANS, "manhwax.org", pageSize = 12, searchPageSize = 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/PantheonScanFr.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/PantheonScanFr.kt new file mode 100644 index 00000000..5fb64759 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/PantheonScanFr.kt @@ -0,0 +1,10 @@ +package org.koitharu.kotatsu.parsers.site.mangareader.fr + +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("PANTHEONSCAN_FR", "Pantheon Scan Fr", "fr") +internal class PantheonScanFr(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.PANTHEONSCAN_FR, "www.pantheon-scan.fr", pageSize = 40, searchPageSize = 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/KomikSan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/KomikSan.kt new file mode 100644 index 00000000..ab3b891b --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/KomikSan.kt @@ -0,0 +1,75 @@ +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.Manga +import org.koitharu.kotatsu.parsers.model.MangaSource +import org.koitharu.kotatsu.parsers.model.MangaTag +import org.koitharu.kotatsu.parsers.model.SortOrder +import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser +import org.koitharu.kotatsu.parsers.util.domain +import org.koitharu.kotatsu.parsers.util.parseHtml +import org.koitharu.kotatsu.parsers.util.urlEncoded + +@MangaSourceParser("KOMIKSAN", "Komik San", "id") +internal class KomikSan(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KOMIKSAN, "komiksan.link", pageSize = 40, searchPageSize = 10) { + + override val selectMangaListImg = "img.attachment-medium" + + override val listUrl = "/list" + override val datePattern = "MMM d, yyyy" + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + if (!query.isNullOrEmpty()) { + if (page > lastSearchPage) { + return emptyList() + } + + val url = buildString { + append("https://") + append(domain) + append("/search?search=") + append(query.urlEncoded()) + append("&page=") + append(page) + + } + + 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}" } + val url = buildString { + append("https://") + append(domain) + append(listUrl) + append("/?order=") + append(sortQuery) + append(tagQuery) + append("&page=") + append(page) + } + + return parseMangaList(webClient.httpGet(url).parseHtml()) + } + +} 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 6a893bac..40070c12 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 @@ -145,7 +145,7 @@ internal class Komikcast(context: MangaLoaderContext) : publicUrl = a.attrAsAbsoluteUrl("href"), rating = rating, isNsfw = isNsfwSource, - coverUrl = it.selectFirst("img.ts-post-image")?.imageUrl().orEmpty(), + coverUrl = it.selectFirst("img.ts-post-image")?.src().orEmpty(), tags = emptySet(), state = null, author = null, @@ -161,7 +161,7 @@ internal class Komikcast(context: MangaLoaderContext) : val test = docs.select("script:containsData(ts_reader)") if (test.isNullOrEmpty()) { return docs.select("div#chapter_body img").map { img -> - val url = img.imageUrl() + 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/mangareader/pt/SssScanlator.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pt/SssScanlator.kt new file mode 100644 index 00000000..d14bf6fb --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pt/SssScanlator.kt @@ -0,0 +1,10 @@ +package org.koitharu.kotatsu.parsers.site.mangareader.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.mangareader.MangaReaderParser + +@MangaSourceParser("SSSSCANLATOR", "SssScanlator", "pt") +internal class SssScanlator(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.SSSSCANLATOR, "sssscanlator.com", pageSize = 20, searchPageSize = 10) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/FrScansCom.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/FrScansCom.kt new file mode 100644 index 00000000..6538c913 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/FrScansCom.kt @@ -0,0 +1,14 @@ +package org.koitharu.kotatsu.parsers.site.mmrcms.fr + +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.mmrcms.MmrcmsParser +import java.util.Locale + +@MangaSourceParser("FRSCANSCOM", "FrScansCom", "fr") +internal class FrScansCom(context: MangaLoaderContext) : + MmrcmsParser(context, MangaSource.FRSCANSCOM, "frscans.com") { + + override val sourceLocale: Locale = Locale.ENGLISH +} diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/Bakai.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/Bakai.kt new file mode 100644 index 00000000..4eea28c4 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/Bakai.kt @@ -0,0 +1,155 @@ +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.util.* + +@MangaSourceParser("BAKAI", "Bakai", "pt", ContentType.HENTAI) +internal class Bakai(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.BAKAI, 15) { + + override val sortOrders: Set = EnumSet.of(SortOrder.UPDATED) + + override val configKeyDomain = ConfigKey.Domain("bakai.org") + + 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("/search/?q=") + append(query.urlEncoded()) + append("&quick=1&type=cms_records1&page=") + append(page.toString()) + } else if (!tags.isNullOrEmpty()) { + append("/search/?tags=") + for (tag in tags) { + append(tag.key) + append(",") + } + append("&quick=1&type=cms_records1&page=") + append(page.toString()) + + } else { + append("/hentai/") + append("page/") + append(page.toString()) + } + } + val doc = webClient.httpGet(url).parseHtml() + if (!tags.isNullOrEmpty() or !query.isNullOrEmpty()) { + + return doc.select("ol.ipsStream li.ipsStreamItem") + .map { div -> + val href = div.selectFirstOrThrow("div.ipsStreamItem_snippet a").attrAsAbsoluteUrl("href") + Manga( + id = generateUid(href), + title = div.selectFirstOrThrow("h2.ipsStreamItem_title").text(), + altTitle = null, + url = href, + publicUrl = href.toAbsoluteUrl(domain), + rating = RATING_UNKNOWN, + isNsfw = true, + coverUrl = div.selectFirstOrThrow("span.ipsThumb img").attrAsAbsoluteUrl("src"), + tags = setOf(), + state = null, + author = null, + source = source, + ) + } + } else { + return doc.select("section.ipsType_normal li.ipsGrid_span4") + .map { div -> + val href = div.selectFirstOrThrow("h2.ipsType_pageTitle a").attrAsRelativeUrl("href") + Manga( + id = generateUid(href), + title = div.selectFirstOrThrow("h2.ipsType_pageTitle").text(), + altTitle = null, + url = href, + publicUrl = href.toAbsoluteUrl(domain), + rating = RATING_UNKNOWN, + isNsfw = true, + 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").parseHtml() + return doc.requireElementById("elNavigation_17_menu").select("li.ipsMenu_item a").mapNotNullToSet { a -> + + MangaTag( + key = a.attr("href").removeSuffix('/').substringAfterLast('/'), + title = a.text(), + source = source, + ) + } + } + + override suspend fun getDetails(manga: Manga): Manga { + val root = + webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml().selectFirstOrThrow("article.ipsContained") + return manga.copy( + altTitle = null, + state = null, + tags = root.select("p:contains(Tags:) span span")[1].text().split(",").mapNotNullToSet { a -> + val tag = a.replace(" ", "") + MangaTag( + key = tag, + title = tag, + source = source, + ) + }, + author = root.selectFirstOrThrow("p:contains(Artista:) span a").text(), + description = root.selectFirstOrThrow("section.ipsType_richText").html(), + 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 getPages(chapter: MangaChapter): List { + val fullUrl = chapter.url.toAbsoluteUrl(domain) + val doc = webClient.httpGet(fullUrl).parseHtml() + val root = doc.body().selectFirstOrThrow("div.pular") + 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/GoldenManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/GoldenManga.kt new file mode 100644 index 00000000..56bcf6f9 --- /dev/null +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/GoldenManga.kt @@ -0,0 +1,143 @@ +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_DESKTOP) + .build() + + + override suspend fun getListPage( + page: Int, + query: String?, + tags: Set?, + sortOrder: SortOrder, + ): List { + + val url = buildString { + append("https://") + append(domain) + append("/mangas") + append("?pagina=") + append(page.toString()) + + if (!query.isNullOrEmpty()) { + append("&search=") + append(query.urlEncoded()) + } + + 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").attrAsAbsoluteUrl("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/wpcomics/WpComicsParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/WpComicsParser.kt index 17700e03..9431a585 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 @@ -40,13 +40,13 @@ internal abstract class WpComicsParser( @JvmField protected val ongoing: Set = setOf( "Đang tiến hành", - "Ongoing" + "Ongoing", ) @JvmField protected val finished: Set = setOf( "Hoàn thành", - "Completed " + "Completed ", ) override suspend fun getListPage( @@ -60,17 +60,17 @@ internal abstract class WpComicsParser( append(domain) append(listUrl) - if(!tags.isNullOrEmpty()){ - append("/") - for (tag in tags) { - append(tag.key) - } + if (!tags.isNullOrEmpty()) { + append("/") + for (tag in tags) { + append(tag.key) + } } append("?page=") append(page.toString()) - if(!query.isNullOrEmpty()){ + if (!query.isNullOrEmpty()) { append("&keyword=") append(query.urlEncoded()) } @@ -171,11 +171,9 @@ internal abstract class WpComicsParser( val dateText = li.selectFirst(selectDate)?.text() val findHours = dateText?.contains(":") - val dateFormat = if(findHours == true) - { + val dateFormat = if (findHours == true) { SimpleDateFormat("HH:mm dd/MM", sourceLocale) - }else - { + } else { SimpleDateFormat(datePattern, sourceLocale) } @@ -220,7 +218,7 @@ internal abstract class WpComicsParser( return when { d.endsWith(" ago") || d.endsWith(" trước") // Handle translated 'ago' in Viêt Nam. - -> parseRelativeDate(date) + -> parseRelativeDate(date) // Handle 'yesterday' and 'today', using midnight d.startsWith("year") -> Calendar.getInstance().apply { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/en/XoxoComics.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/en/XoxoComics.kt index 7e9723b6..e71f8714 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/en/XoxoComics.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/en/XoxoComics.kt @@ -10,7 +10,7 @@ import java.util.EnumSet @MangaSourceParser("XOXOCOMICS", "Xoxo Comics", "vi", ContentType.COMICS) internal class XoxoComics(context: MangaLoaderContext) : - WpComicsParser(context, MangaSource.XOXOCOMICS, "xoxocomics.net", 50){ + WpComicsParser(context, MangaSource.XOXOCOMICS, "xoxocomics.net", 50) { override val listUrl = "/genre" override val datePattern = "MM/dd/yyyy" @@ -19,7 +19,7 @@ internal class XoxoComics(context: MangaLoaderContext) : SortOrder.UPDATED, SortOrder.NEWEST, SortOrder.POPULARITY, - SortOrder.ALPHABETICAL + SortOrder.ALPHABETICAL, ) override suspend fun getListPage( @@ -32,32 +32,31 @@ internal class XoxoComics(context: MangaLoaderContext) : append("https://") append(domain) - if(!query.isNullOrEmpty()){ + if (!query.isNullOrEmpty()) { append("/search?keyword=") append(query.urlEncoded()) append("&page=") append(page.toString()) - }else - { - append(listUrl) - if(!tags.isNullOrEmpty()){ - append("/") - for (tag in tags) { - append(tag.key) + } else { + append(listUrl) + if (!tags.isNullOrEmpty()) { + append("/") + for (tag in tags) { + append(tag.key) + } } - } - append("/") - when (sortOrder) { - SortOrder.POPULARITY -> append("popular") - SortOrder.UPDATED -> append("") - SortOrder.NEWEST -> append("newest") - SortOrder.ALPHABETICAL -> append("alphabet") - else -> append("") - } + append("/") + when (sortOrder) { + SortOrder.POPULARITY -> append("popular") + SortOrder.UPDATED -> append("") + SortOrder.NEWEST -> append("newest") + SortOrder.ALPHABETICAL -> append("alphabet") + else -> append("") + } - append("?page=") - append(page.toString()) + append("?page=") + append(page.toString()) } } @@ -98,5 +97,4 @@ internal class XoxoComics(context: MangaLoaderContext) : ) } } - } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/vi/Nettruyenmax.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/vi/Nettruyenmax.kt index 08a416ee..a43e6597 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/vi/Nettruyenmax.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/vi/Nettruyenmax.kt @@ -9,7 +9,7 @@ import org.koitharu.kotatsu.parsers.site.wpcomics.WpComicsParser @MangaSourceParser("NETTRUYENMAX", "Nettruyenmax", "vi") internal class Nettruyenmax(context: MangaLoaderContext) : - WpComicsParser(context, MangaSource.NETTRUYENMAX, "www.nettruyenmax.com", 35){ + WpComicsParser(context, MangaSource.NETTRUYENMAX, "www.nettruyenmax.com", 35) { override val listUrl = "/tim-truyen" } 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 8d09bfbd..196a0a58 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 @@ -60,7 +60,7 @@ internal abstract class ZMangaParser( append("https://") append(domain) append("/$listUrl") - if(page > 1){ + if (page > 1) { append("page/") append(page.toString()) append("/") 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 361f8521..4410fa15 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 @@ -17,7 +17,7 @@ import java.text.SimpleDateFormat // Info: Some scans are password-protected @MangaSourceParser("MAID_ID", "Maid Id", "id") internal class MaidId(context: MangaLoaderContext) : - ZMangaParser(context, MangaSource.MAID_ID, "www.maid.my.id"){ + ZMangaParser(context, MangaSource.MAID_ID, "www.maid.my.id") { override suspend fun getChapters(manga: Manga, doc: Document): List { val dateFormat = SimpleDateFormat(datePattern, sourceLocale) @@ -25,7 +25,8 @@ internal class MaidId(context: MangaLoaderContext) : val a = li.selectFirstOrThrow("a") val href = a.attrAsRelativeUrl("href") val dateText = li.selectFirst(selectDate)?.text() - val numChapter = li.selectFirstOrThrow(".flexch-infoz span").html().substringAfterLast("Chapter ").substringBefore(" { val dateFormat = SimpleDateFormat(datePattern, sourceLocale) @@ -25,7 +25,8 @@ internal class ShiroDoujin(context: MangaLoaderContext) : val a = li.selectFirstOrThrow("a") val href = a.attrAsRelativeUrl("href") val dateText = li.selectFirst(selectDate)?.text() - val numChapter = li.selectFirstOrThrow(".flexch-infoz span").html().substringAfterLast("Chapter ").substringBefore(" = arrayOf("data-src", "data-cfsrc", "data-original", "data-cdn", "data-sizes", "src")): String? { +fun Element.src(names: Array = arrayOf("data-src", "data-cfsrc", "data-original", "data-cdn", "data-sizes", "data-lazy-src", "src")): String? { for (name in names) { val value = attrAsAbsoluteUrlOrNull(name) if (value != null) { From bb4ea0537512d18e5b4f460e800a2d7d99e72118 Mon Sep 17 00:00:00 2001 From: devi Date: Sat, 5 Aug 2023 18:18:25 +0200 Subject: [PATCH 2/3] fix domaine peacescans --- .../koitharu/kotatsu/parsers/site/mangareader/en/PeaceScans.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/PeaceScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/PeaceScans.kt index ca2311bb..b32e2381 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/PeaceScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/PeaceScans.kt @@ -7,4 +7,4 @@ import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser @MangaSourceParser("PEACESCANS", "PeaceScans", "en") internal class PeaceScans(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.PEACESCANS, "manhwax.org", pageSize = 12, searchPageSize = 10) + MangaReaderParser(context, MangaSource.PEACESCANS, "peacescans.com", pageSize = 14, searchPageSize = 10) From c290ba54369f3da7ce4f6db7f97e2090a6157084 Mon Sep 17 00:00:00 2001 From: Koitharu Date: Sun, 6 Aug 2023 09:00:04 +0300 Subject: [PATCH 3/3] Update src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/DynastyScans.kt --- .../kotlin/org/koitharu/kotatsu/parsers/site/en/DynastyScans.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/DynastyScans.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/DynastyScans.kt index 1609dc27..34286593 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/DynastyScans.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/DynastyScans.kt @@ -134,7 +134,7 @@ internal class DynastyScans(context: MangaLoaderContext) : PagedMangaParser(cont val dateFormat = SimpleDateFormat("MMM dd yy", sourceLocale) return doc.body().select("dl.chapter-list dd").mapChapters { i, li -> val a = li.selectFirstOrThrow("a") - val href = a.attrAsRelativeUrlOrNull("href") ?: li.parseFailed("Link is missing") + val href = a.attrAsRelativeUrl("href") val dateText = li.select("small").last()?.text()?.replace("released ", "")?.replace("'", "") MangaChapter( id = generateUid(href),