From 1293233ad92fdda2d68db110c43d77b5b839b4d6 Mon Sep 17 00:00:00 2001 From: devi Date: Sat, 25 Nov 2023 20:04:47 +0100 Subject: [PATCH] fix getListPage Some sources madara --- .../parsers/site/madara/all/Manga18Fx.kt | 54 ++++++----- .../parsers/site/madara/all/Manhwa18Cc.kt | 56 ++++++------ .../parsers/site/madara/en/Hentai4Free.kt | 69 +++++++------- .../parsers/site/madara/en/InstaManhwa.kt | 64 ++++++------- .../parsers/site/madara/en/IsekaiScan.kt | 78 ++++++++-------- .../site/madara/en/IsekaiScanEuParser.kt | 89 ++++++++++++------- .../parsers/site/madara/en/MangaDass.kt | 76 ++++++++-------- .../parsers/site/madara/en/MangaDna.kt | 68 +++++++------- .../parsers/site/madara/en/MangaPure.kt | 70 ++++++++------- .../kotatsu/parsers/site/madara/en/Manhwaz.kt | 79 +++++++++------- .../site/madara/es/DragonTranslationParser.kt | 55 ++++++------ .../parsers/site/madara/es/MonarcaManga.kt | 84 ----------------- .../parsers/site/madara/es/TmoManga.kt | 42 +++++---- .../parsers/site/madara/id/ManhwaHub.kt | 57 +++++------- .../parsers/site/madara/vi/Saytruyenhay.kt | 66 ++++++++------ 15 files changed, 503 insertions(+), 504 deletions(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Manga18Fx.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Manga18Fx.kt index 5547d042..60451400 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Manga18Fx.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Manga18Fx.kt @@ -19,39 +19,49 @@ internal class Manga18Fx(context: MangaLoaderContext) : override val selectDate = "span.chapter-time" override val selectChapter = "li.a-h" override val selectBodyPage = "div.read-content" - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val tag = tags.oneOrThrowIfMany() + + init { + paginator.firstPage = 1 + searchPaginator.firstPage = 1 + } + + override val availableStates: Set get() = emptySet() + + override suspend fun getListPage(page: Int, filter: MangaListFilter?): List { + val url = buildString { append("https://") append(domain) - val pages = page + 1 - when { - !query.isNullOrEmpty() -> { - + when (filter) { + is MangaListFilter.Search -> { append("/search?q=") - append(query.urlEncoded()) + append(filter.query.urlEncoded()) append("&page=") - append(pages) + append(page.toString()) } - !tags.isNullOrEmpty() -> { - append("/$tagPrefix") - append(tag?.key.orEmpty()) - if (pages > 1) { - append("/") - append(pages) + is MangaListFilter.Advanced -> { + + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("/$tagPrefix") + append(tag?.key.orEmpty()) + if (page > 1) { + append("/") + append(page.toString()) + } + } else { + if (page > 1) { + append("/page/") + append(page) + } } } - else -> { - if (pages > 1) { + null -> { + if (page > 1) { append("/page/") - append(pages) + append(page) } } } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Manhwa18Cc.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Manhwa18Cc.kt index 83274803..8e5ca159 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Manhwa18Cc.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Manhwa18Cc.kt @@ -26,48 +26,48 @@ internal class Manhwa18Cc(context: MangaLoaderContext) : searchPaginator.firstPage = 1 } - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val tag = tags.oneOrThrowIfMany() + override val availableStates: Set get() = emptySet() + + override suspend fun getListPage(page: Int, filter: MangaListFilter?): List { val url = buildString { append("https://") append(domain) - when { - !query.isNullOrEmpty() -> { + when (filter) { + + is MangaListFilter.Search -> { append("/search?q=") - append(query.urlEncoded()) + append(filter.query.urlEncoded()) append("&page=") append(page.toString()) } - !tags.isNullOrEmpty() -> { - append("/$tagPrefix") - append(tag?.key.orEmpty()) + is MangaListFilter.Advanced -> { + + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("/$tagPrefix") + append(tag?.key.orEmpty()) + } else { + append("/$listUrl") + } + if (page > 1) { append(page.toString()) } - append("?") - } - else -> { - append("/$listUrl") - if (page > 1) { - append(page) + append("?orderby=") + when (filter.sortOrder) { + SortOrder.POPULARITY -> append("trending") + SortOrder.UPDATED -> append("latest") + SortOrder.ALPHABETICAL -> append("alphabet") + SortOrder.RATING -> append("rating") + else -> append("latest") } - append("?") } - } - append("m_orderby=") - when (sortOrder) { - SortOrder.POPULARITY -> append("trending") - SortOrder.UPDATED -> append("latest") - SortOrder.ALPHABETICAL -> append("alphabet") - SortOrder.RATING -> append("rating") - else -> append("latest") + + null -> { + append("?s&post_type=wp-manga&m_orderby=latest") + } } } val doc = webClient.httpGet(url).parseHtml() 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 0a0e3334..fdca0963 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 @@ -5,6 +5,7 @@ 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.MangaListFilter import org.koitharu.kotatsu.parsers.model.MangaSource import org.koitharu.kotatsu.parsers.model.MangaState import org.koitharu.kotatsu.parsers.model.MangaTag @@ -20,48 +21,48 @@ internal class Hentai4Free(context: MangaLoaderContext) : override val listUrl = "" override val withoutAjax = true override val datePattern = "MMMM dd, yyyy" + override val selectGenre = "div.tags-content a" + override val availableStates: Set get() = emptySet() - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - - val tag = tags.oneOrThrowIfMany() + init { + paginator.firstPage = 1 + searchPaginator.firstPage = 1 + } + override suspend fun getListPage(page: Int, filter: MangaListFilter?): List { val url = buildString { append("https://") append(domain) - val pages = page + 1 - when { - !query.isNullOrEmpty() -> { + when (filter) { + is MangaListFilter.Search -> { append("/page/") - append(pages.toString()) + append(page.toString()) append("/?s=") - append(query.urlEncoded()) - append("&post_type=wp-manga&") + append(filter.query.urlEncoded()) + append("&post_type=wp-manga") } - !tags.isNullOrEmpty() -> { - append("/$tagPrefix") - append(tag?.key.orEmpty()) - append("/") - if (pages > 1) { - append("page/") - append(pages.toString()) - } - } + is MangaListFilter.Advanced -> { - else -> { - - if (pages > 1) { - append("/page/") - append(pages.toString()) + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("/$tagPrefix") + append(tag?.key.orEmpty()) + append("/") + if (page > 1) { + append("page/") + append(page.toString()) + } + } else { + if (page > 1) { + append("/page/") + append(page.toString()) + } } + append("/?m_orderby=") - when (sortOrder) { + when (filter.sortOrder) { SortOrder.POPULARITY -> append("views") SortOrder.UPDATED -> append("latest") SortOrder.NEWEST -> append("new-manga") @@ -69,9 +70,17 @@ internal class Hentai4Free(context: MangaLoaderContext) : SortOrder.RATING -> append("rating") } } - } + null -> { + if (page > 1) { + append("/page/") + append(page.toString()) + } + append("/?m_orderby=latest") + } + } } + val doc = webClient.httpGet(url).parseHtml() return doc.select("div.row.c-tabs-item__content").ifEmpty { diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/InstaManhwa.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/InstaManhwa.kt index 1febb799..cde6e581 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/InstaManhwa.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/InstaManhwa.kt @@ -23,46 +23,48 @@ internal class InstaManhwa(context: MangaLoaderContext) : SortOrder.NEWEST, ) - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val tag = tags.oneOrThrowIfMany() + override val availableStates: Set get() = emptySet() + + init { + paginator.firstPage = 1 + searchPaginator.firstPage = 1 + } + + override suspend fun getListPage(page: Int, filter: MangaListFilter?): List { val url = buildString { append("https://") append(domain) - val pages = page + 1 - - when { - !query.isNullOrEmpty() -> { - - append("/?search=") - append(query.urlEncoded()) + when (filter) { + is MangaListFilter.Search -> { + append("/search?q=") + append(filter.query.urlEncoded()) append("&page=") - append(pages.toString()) - append("&post_type=wp-manga&post_type=wp-manga") + append(page.toString()) } - !tags.isNullOrEmpty() -> { - append("/genre/") - append(tag?.key.orEmpty()) - append("?page=") - append(pages.toString()) + is MangaListFilter.Advanced -> { + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("/genre/") + append(tag?.key.orEmpty()) + append("?page=") + append(page.toString()) + } else { + when (filter.sortOrder) { + SortOrder.UPDATED -> append("/latest") + SortOrder.NEWEST -> append("/new") + SortOrder.ALPHABETICAL -> append("/alphabet") + else -> append("/latest") + } + append("?page=") + append(page.toString()) + } } - else -> { - - when (sortOrder) { - SortOrder.UPDATED -> append("/latest") - SortOrder.NEWEST -> append("/new") - SortOrder.ALPHABETICAL -> append("/alphabet") - else -> append("/latest") - } - append("?page=") - append(pages.toString()) + null -> { + append("/latest?page=") + append(page.toString()) } } } 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 6464a2de..c0a9278f 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 @@ -22,50 +22,58 @@ internal class IsekaiScan(context: MangaLoaderContext) : SortOrder.UPDATED, ) - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val tag = tags.oneOrThrowIfMany() + override val availableStates: Set get() = emptySet() + + init { + paginator.firstPage = 1 + searchPaginator.firstPage = 1 + } + + override suspend fun getListPage(page: Int, filter: MangaListFilter?): List { + val url = buildString { append("https://") append(domain) - val pages = page + 1 - - when { - !query.isNullOrEmpty() -> { - + when (filter) { + is MangaListFilter.Search -> { append("/?search=") - append(query.urlEncoded()) + append(filter.query.urlEncoded()) append("&page=") - append(pages.toString()) + append(page.toString()) append("&post_type=wp-manga") } - !tags.isNullOrEmpty() -> { - append("/mangas/") - append(tag?.key.orEmpty()) - append("?orderby=2&page=") - append(pages.toString()) - + is MangaListFilter.Advanced -> { + + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("/$tagPrefix") + append(tag?.key.orEmpty()) + append("?orderby=") + when (filter.sortOrder) { + SortOrder.POPULARITY -> append("2") + SortOrder.UPDATED -> append("3") + else -> append("3") + } + append("&page=") + append(page.toString()) + } else { + when (filter.sortOrder) { + SortOrder.POPULARITY -> append("/popular-manga") + SortOrder.UPDATED -> append("/latest-manga") + else -> append("/latest-manga") + } + append("?page=") + append(page.toString()) + } } - else -> { - - if (sortOrder == SortOrder.POPULARITY) { - append("/popular-manga") - } - if (sortOrder == SortOrder.UPDATED) { - append("/latest-manga") - } - append("?page=") - append(pages.toString()) + null -> { + append("/latest-manga?page=") + append(page.toString()) } } } - val doc = webClient.httpGet(url).parseHtml() return doc.select("div.row.c-tabs-item__content").ifEmpty { @@ -91,8 +99,8 @@ internal class IsekaiScan(context: MangaLoaderContext) : author = summary?.selectFirst(".mg_author")?.selectFirst("a")?.ownText(), state = when (summary?.selectFirst(".mg_status")?.selectFirst(".summary-content")?.ownText()?.trim() ?.lowercase()) { - "Ongoing" -> MangaState.ONGOING - "Completed " -> MangaState.FINISHED + "ongoing" -> MangaState.ONGOING + "completed " -> MangaState.FINISHED else -> null }, source = source, @@ -133,8 +141,8 @@ internal class IsekaiScan(context: MangaLoaderContext) : override suspend fun getPages(chapter: MangaChapter): List { val fullUrl = chapter.url.toAbsoluteUrl(domain) val doc = webClient.httpGet(fullUrl).parseHtml() - val urlarray = doc.select("p#arraydata").text().split(",").toTypedArray() - return urlarray.map { url -> + val urlArray = doc.select("p#arraydata").text().split(",").toTypedArray() + return urlArray.map { url -> MangaPage( id = generateUid(url), url = url, diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/IsekaiScanEuParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/IsekaiScanEuParser.kt index 01657f53..c5b561e3 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/IsekaiScanEuParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/IsekaiScanEuParser.kt @@ -14,50 +14,71 @@ internal class IsekaiScanEuParser(context: MangaLoaderContext) : override val withoutAjax = true override val listUrl = "mangax/" - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val tag = tags.oneOrThrowIfMany() + init { + paginator.firstPage = 1 + searchPaginator.firstPage = 1 + } + + override suspend fun getListPage(page: Int, filter: MangaListFilter?): List { + val url = buildString { append("https://") append(domain) - val pages = page + 1 - when { - !query.isNullOrEmpty() -> { - append("/page/") - append(pages.toString()) + when (filter) { + + is MangaListFilter.Search -> { + if (page > 1) { + append("/page/") + append(page.toString()) + } append("/?s=") - append(query.urlEncoded()) - append("&post_type=wp-manga&") + append(filter.query.urlEncoded()) + append("&post_type=wp-manga") } - !tags.isNullOrEmpty() -> { - append("/$tagPrefix") - append(tag?.key.orEmpty()) - append("/page/") - append(pages.toString()) - append("?") - } + is MangaListFilter.Advanced -> { - else -> { + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("/$tagPrefix") + append(tag?.key.orEmpty()) + if (page > 1) { + append("/page/") + append(page.toString()) + } + append("/?") + } else { + if (page > 1) { + append("/page/") + append(page.toString()) + } + append("/?s=&post_type=wp-manga") + filter.states.forEach { + append("&status[]=") + when (it) { + MangaState.ONGOING -> append("on-going") + MangaState.FINISHED -> append("end") + MangaState.ABANDONED -> append("canceled") + MangaState.PAUSED -> append("on-hold") + } + } + append("&") + } - append("/$listUrl") - append("/page/") - append(pages.toString()) - append("?") + append("m_orderby=") + when (filter.sortOrder) { + SortOrder.POPULARITY -> append("views") + SortOrder.UPDATED -> append("latest") + SortOrder.NEWEST -> append("new-manga") + SortOrder.ALPHABETICAL -> append("alphabet") + SortOrder.RATING -> append("rating") + } + } + + null -> { + append("/?s&post_type=wp-manga&m_orderby=latest") } - } - append("m_orderby=") - when (sortOrder) { - SortOrder.POPULARITY -> append("views") - SortOrder.UPDATED -> append("latest") - SortOrder.NEWEST -> append("new-manga") - SortOrder.ALPHABETICAL -> append("alphabet") - SortOrder.RATING -> append("rating") } } val doc = webClient.httpGet(url).parseHtml() diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDass.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDass.kt index 3520f9ff..d17a4199 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDass.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDass.kt @@ -19,55 +19,61 @@ internal class MangaDass(context: MangaLoaderContext) : override val selectChapter = "li.a-h" override val selectDesc = "div.ss-manga" - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val tag = tags.oneOrThrowIfMany() + override val availableStates: Set get() = emptySet() + + init { + paginator.firstPage = 1 + searchPaginator.firstPage = 1 + } + + override suspend fun getListPage(page: Int, filter: MangaListFilter?): List { + val url = buildString { append("https://") append(domain) - val pages = page + 1 - - when { - !query.isNullOrEmpty() -> { - - append("/?s=") - append(query.urlEncoded()) + when (filter) { + is MangaListFilter.Search -> { + append("/search?q=") + append(filter.query.urlEncoded()) append("&page=") - append(pages.toString()) + append(page.toString()) } - !tags.isNullOrEmpty() -> { - append("/$tagPrefix") - append(tag?.key.orEmpty()) - append("/") - append(pages.toString()) - append("?") + is MangaListFilter.Advanced -> { + + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("/$tagPrefix") + append(tag?.key.orEmpty()) + append("/") + append(page.toString()) + append("?") + } else { + append("/$listUrl") + append("/") + append(page.toString()) + append("?") + } + + append("orderby=") + when (filter.sortOrder) { + SortOrder.POPULARITY -> append("views") + SortOrder.UPDATED -> append("latest") + SortOrder.NEWEST -> append("new-manga") + SortOrder.ALPHABETICAL -> append("alphabet") + SortOrder.RATING -> append("rating") + } } - else -> { - + null -> { append("/$listUrl") append("/") - append(pages.toString()) - append("?") + append(page.toString()) + append("?orderby=latest") } } - append("orderby=") - when (sortOrder) { - SortOrder.POPULARITY -> append("views") - SortOrder.UPDATED -> append("latest") - SortOrder.NEWEST -> append("new-manga") - SortOrder.ALPHABETICAL -> append("alphabet") - SortOrder.RATING -> append("rating") - } } val doc = webClient.httpGet(url).parseHtml() - - return doc.select("div.row.c-tabs-item__content").ifEmpty { doc.select("div.page-item-detail") }.map { div -> diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDna.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDna.kt index 4e8d905c..e3416f46 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDna.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDna.kt @@ -18,53 +18,53 @@ internal class MangaDna(context: MangaLoaderContext) : override val withoutAjax = true override val selectDesc = "div.dsct" override val selectChapter = "li.a-h" + override val availableStates: Set get() = emptySet() - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val tag = tags.oneOrThrowIfMany() + override suspend fun getListPage(page: Int, filter: MangaListFilter?): 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&") + when (filter) { + is MangaListFilter.Search -> { + append("/search?q=") + append(filter.query.urlEncoded()) + append("&page=") + append(page.toString()) } - !tags.isNullOrEmpty() -> { - append("/$tagPrefix") - append(tag?.key.orEmpty()) - append("/page/") - append(pages.toString()) - append("?") + is MangaListFilter.Advanced -> { + + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("/$tagPrefix") + append(tag?.key.orEmpty()) + append("/") + append(page.toString()) + } else { + append("/$listUrl") + append("/page/") + append(page.toString()) + } + + append("?orderby=") + when (filter.sortOrder) { + SortOrder.POPULARITY -> append("trending") + SortOrder.UPDATED -> append("latest") + SortOrder.ALPHABETICAL -> append("alphabet") + SortOrder.RATING -> append("rating") + else -> append("latest") + } } - else -> { - + null -> { append("/$listUrl") append("/page/") - append(pages.toString()) - append("?") + append(page.toString()) + append("?orderby=latest") } } - append("m_orderby=") - when (sortOrder) { - SortOrder.POPULARITY -> append("views") - SortOrder.UPDATED -> append("latest") - SortOrder.NEWEST -> append("new-manga") - SortOrder.ALPHABETICAL -> append("alphabet") - SortOrder.RATING -> append("rating") - } } + val doc = webClient.httpGet(url).parseHtml() diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaPure.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaPure.kt index 44e53ff6..6277b7ce 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaPure.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaPure.kt @@ -21,46 +21,54 @@ internal class MangaPure(context: MangaLoaderContext) : SortOrder.UPDATED, ) - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val tag = tags.oneOrThrowIfMany() + override val availableStates: Set get() = emptySet() + + init { + paginator.firstPage = 1 + searchPaginator.firstPage = 1 + } + + override suspend fun getListPage(page: Int, filter: MangaListFilter?): List { val url = buildString { append("https://") append(domain) - val pages = page + 1 - - when { - !query.isNullOrEmpty() -> { - - append("/?search=") - append(query.urlEncoded()) + when (filter) { + is MangaListFilter.Search -> { + append("/search?s=") + append(filter.query.urlEncoded()) append("&page=") - append(pages.toString()) + append(page.toString()) append("&post_type=wp-manga") } - !tags.isNullOrEmpty() -> { - append("/mangas/") - append(tag?.key.orEmpty()) - append("?orderby=2&page=") - append(pages.toString()) - + is MangaListFilter.Advanced -> { + + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("/$tagPrefix") + append(tag?.key.orEmpty()) + append("?orderby=") + when (filter.sortOrder) { + SortOrder.POPULARITY -> append("2") + SortOrder.UPDATED -> append("3") + else -> append("3") + } + append("&page=") + append(page.toString()) + } else { + when (filter.sortOrder) { + SortOrder.POPULARITY -> append("/popular-manga") + SortOrder.UPDATED -> append("/latest-manga") + else -> append("/latest-manga") + } + append("?page=") + append(page.toString()) + } } - else -> { - - if (sortOrder == SortOrder.POPULARITY) { - append("/popular-manga") - } - if (sortOrder == SortOrder.UPDATED) { - append("/latest-manga") - } - append("?page=") - append(pages.toString()) + null -> { + append("/latest-manga?page=") + append(page.toString()) } } } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwaz.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwaz.kt index b2ada718..4e8bc2fe 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwaz.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwaz.kt @@ -5,6 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.* import org.koitharu.kotatsu.parsers.site.madara.MadaraParser import org.koitharu.kotatsu.parsers.util.* +import java.util.EnumSet @MangaSourceParser("MANHWAZ", "ManhwaZ", "en") internal class Manhwaz(context: MangaLoaderContext) : @@ -15,51 +16,65 @@ internal class Manhwaz(context: MangaLoaderContext) : override val withoutAjax = true override val selectTestAsync = "div.list-chapter" - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val tag = tags.oneOrThrowIfMany() + override val availableStates: Set get() = emptySet() + + override val availableSortOrders: Set = EnumSet.of( + SortOrder.UPDATED, + SortOrder.POPULARITY, + SortOrder.NEWEST, + SortOrder.RATING, + ) + + init { + paginator.firstPage = 1 + searchPaginator.firstPage = 1 + } + + override suspend fun getListPage(page: Int, filter: MangaListFilter?): List { val url = buildString { append("https://") append(domain) - val pages = page + 1 - - when { - !query.isNullOrEmpty() -> { - + when (filter) { + is MangaListFilter.Search -> { append("/search?s=") - append(query.urlEncoded()) + append(filter.query.urlEncoded()) append("&page=") - append(pages.toString()) + append(page.toString()) } - !tags.isNullOrEmpty() -> { - append("/$tagPrefix") - append(tag?.key.orEmpty()) - append("?page=") - append(pages.toString()) - append("&") - } + is MangaListFilter.Advanced -> { - else -> { + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("/$tagPrefix") + append(tag?.key.orEmpty()) + append("?page=") + append(page.toString()) + append("&") + } else { + append("/$listUrl") + append("?page=") + append(page.toString()) + append("&") + } + append("m_orderby=") + when (filter.sortOrder) { + SortOrder.POPULARITY -> append("views") + SortOrder.UPDATED -> append("latest") + SortOrder.NEWEST -> append("new") + SortOrder.RATING -> append("rating") + else -> append("latest") + } + } + + null -> { append("/$listUrl") append("?page=") - append(pages.toString()) - append("&") + append(page.toString()) + append("&m_orderby=latest") } } - append("m_orderby=") - when (sortOrder) { - SortOrder.POPULARITY -> append("views") - SortOrder.UPDATED -> append("latest") - SortOrder.NEWEST -> append("new-manga") - SortOrder.ALPHABETICAL -> append("alphabet") - SortOrder.RATING -> append("rating") - } } val doc = webClient.httpGet(url).parseHtml() diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/DragonTranslationParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/DragonTranslationParser.kt index a4afe517..b86bcbb8 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/DragonTranslationParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/DragonTranslationParser.kt @@ -3,8 +3,9 @@ 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.Manga +import org.koitharu.kotatsu.parsers.model.MangaListFilter import org.koitharu.kotatsu.parsers.model.MangaSource -import org.koitharu.kotatsu.parsers.model.MangaTag +import org.koitharu.kotatsu.parsers.model.MangaState import org.koitharu.kotatsu.parsers.model.SortOrder import org.koitharu.kotatsu.parsers.site.madara.MadaraParser import org.koitharu.kotatsu.parsers.util.* @@ -13,48 +14,46 @@ import java.util.* @MangaSourceParser("DRAGONTRANSLATION", "Dragon Translation", "es") internal class DragonTranslationParser(context: MangaLoaderContext) : MadaraParser(context, MangaSource.DRAGONTRANSLATION, "dragontranslation.net", 30) { - - override val availableSortOrders: Set = EnumSet.of(SortOrder.UPDATED) - override val selectPage = "div#chapter_imgs img" + override val availableSortOrders: Set = EnumSet.of(SortOrder.UPDATED) + override val availableStates: Set get() = emptySet() - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - - val tag = tags.oneOrThrowIfMany() + init { + paginator.firstPage = 1 + searchPaginator.firstPage = 1 + } + override suspend fun getListPage(page: Int, filter: MangaListFilter?): List { val url = buildString { append("https://") append(domain) - val pages = page + 1 - - when { - !query.isNullOrEmpty() -> { + when (filter) { + is MangaListFilter.Search -> { append("/mangas?buscar=") - append(query.urlEncoded()) + append(filter.query.urlEncoded()) append("&page=") - append(pages.toString()) + append(page.toString()) } - !tags.isNullOrEmpty() -> { - append("/mangas?tag=") - append(tag?.key.orEmpty()) - append("&page=") - append(pages.toString()) - } + is MangaListFilter.Advanced -> { - else -> { + append("/mangas?page=") + append(page.toString()) - append("/mangas") - append("?page=") - append(pages.toString()) + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("&tag=") + append(tag?.key.orEmpty()) + } + } + + null -> { + append("/mangas?page=") + append(page.toString()) } } } + val doc = webClient.httpGet(url).parseHtml() return doc.select("div.video-bg div.col-6 ").map { div -> diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/MonarcaManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/MonarcaManga.kt index 9f4d6186..48b58636 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/MonarcaManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/MonarcaManga.kt @@ -4,93 +4,9 @@ import org.koitharu.kotatsu.parsers.MangaLoaderContext import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.* import org.koitharu.kotatsu.parsers.site.madara.MadaraParser -import org.koitharu.kotatsu.parsers.util.* @MangaSourceParser("MONARCAMANGA", "MonarcaManga", "es") internal class MonarcaManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.MONARCAMANGA, "monarcamanga.com") { - override val tagPrefix = "manga-generos/" - override val withoutAjax = true - - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val tag = tags.oneOrThrowIfMany() - 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") - append(tag?.key.orEmpty()) - append("/page/") - append(pages.toString()) - append("?") - } - - else -> { - - append("/$listUrl") - append("/page/") - append(pages.toString()) - append("?") - } - } - append("m_orderby=") - when (sortOrder) { - SortOrder.POPULARITY -> append("views") - SortOrder.UPDATED -> append("latest") - SortOrder.NEWEST -> append("new-manga") - SortOrder.ALPHABETICAL -> append("alphabet") - SortOrder.RATING -> append("rating") - } - } - 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 = (div?.selectFirst("h3") ?: div?.selectFirst("h4"))?.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/es/TmoManga.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TmoManga.kt index 641b79f7..1ec9a6df 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TmoManga.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TmoManga.kt @@ -16,44 +16,49 @@ internal class TmoManga(context: MangaLoaderContext) : override val listUrl = "biblioteca/" override val selectGenre = "div.summary-content a.tags_manga" override val withoutAjax = true + override val availableSortOrders: Set = EnumSet.of(SortOrder.POPULARITY) + override val availableStates: Set get() = emptySet() init { paginator.firstPage = 1 searchPaginator.firstPage = 1 } - override val availableSortOrders: Set = EnumSet.of(SortOrder.POPULARITY) - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val tag = tags.oneOrThrowIfMany() + override suspend fun getListPage(page: Int, filter: MangaListFilter?): List { val url = buildString { append("https://") append(domain) - when { - !query.isNullOrEmpty() -> { + when (filter) { + is MangaListFilter.Search -> { append("/$listUrl") append("?search=") - append(query.urlEncoded()) + append(filter.query.urlEncoded()) if (page > 1) { append("&page=") append(page) } } - !tags.isNullOrEmpty() -> { - append("/$tagPrefix") - append(tag?.key.orEmpty()) - if (page > 1) { - append("?page=") - append(page) + is MangaListFilter.Advanced -> { + + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("/$tagPrefix") + append(tag?.key.orEmpty()) + if (page > 1) { + append("?page=") + append(page) + } + } else { + append("/$listUrl") + if (page > 1) { + append("?page=") + append(page) + } } } - else -> { + null -> { append("/$listUrl") if (page > 1) { append("?page=") @@ -62,6 +67,7 @@ internal class TmoManga(context: MangaLoaderContext) : } } } + val doc = webClient.httpGet(url).parseHtml() return doc.select("div.page-item-detail").map { div -> diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/ManhwaHub.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/ManhwaHub.kt index 36f06b33..a4c1991f 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/ManhwaHub.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/ManhwaHub.kt @@ -17,56 +17,47 @@ internal class ManhwaHub(context: MangaLoaderContext) : override val withoutAjax = true override val listUrl = "genre/manhwa" override val selectTestAsync = "ul.box-list-chapter" + override val availableStates: Set get() = emptySet() + override val availableSortOrders: Set = EnumSet.of(SortOrder.UPDATED) init { paginator.firstPage = 1 searchPaginator.firstPage = 1 } - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val tag = tags.oneOrThrowIfMany() + override suspend fun getListPage(page: Int, filter: MangaListFilter?): List { val url = buildString { append("https://") append(domain) - when { - !query.isNullOrEmpty() -> { + when (filter) { + is MangaListFilter.Search -> { append("/search?s=") - append(query.urlEncoded()) + append(filter.query.urlEncoded()) append("&page=") - append(page) - append("&") + append(page.toString()) } - !tags.isNullOrEmpty() -> { - append("/$tagPrefix") - append(tag?.key.orEmpty()) - append("?page=") - append(page) - append("&") - } + is MangaListFilter.Advanced -> { - else -> { + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("/$tagPrefix") + append(tag?.key.orEmpty()) + append("?page=") + append(page.toString()) + append("&m_orderby=latest") + } else { + append("/?page=") + append(page.toString()) + } - append("/$listUrl") - append("?page=") - append(page) - append("&") - } - } + } - append("m_orderby=") - when (sortOrder) { - SortOrder.POPULARITY -> append("views") - SortOrder.UPDATED -> append("latest") - SortOrder.NEWEST -> append("new-manga") - SortOrder.ALPHABETICAL -> append("alphabet") - SortOrder.RATING -> append("rating") + null -> { + append("/?page=") + append(page.toString()) + } } } val doc = webClient.httpGet(url).parseHtml() diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/vi/Saytruyenhay.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/vi/Saytruyenhay.kt index c69b31b1..6a67b7e2 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/vi/Saytruyenhay.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/vi/Saytruyenhay.kt @@ -7,6 +7,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.model.* import org.koitharu.kotatsu.parsers.site.madara.MadaraParser import org.koitharu.kotatsu.parsers.util.* +import java.util.EnumSet @MangaSourceParser("SAYTRUYENHAY", "Saytruyenhay", "vi") internal class Saytruyenhay(context: MangaLoaderContext) : @@ -15,50 +16,57 @@ internal class Saytruyenhay(context: MangaLoaderContext) : override val tagPrefix = "genre/" override val withoutAjax = true override val listUrl = "public/genre/manga/" + override val availableStates: Set get() = emptySet() + override val availableSortOrders: Set = + EnumSet.of(SortOrder.POPULARITY, SortOrder.UPDATED, SortOrder.RATING, SortOrder.NEWEST) - override suspend fun getListPage( - page: Int, - query: String?, - tags: Set?, - sortOrder: SortOrder, - ): List { - val tag = tags.oneOrThrowIfMany() + init { + paginator.firstPage = 1 + searchPaginator.firstPage = 1 + } + + override suspend fun getListPage(page: Int, filter: MangaListFilter?): List { val url = buildString { append("https://") append(domain) - val pages = page + 1 - - when { - !query.isNullOrEmpty() -> { - - append("/public/search?s=") - append(query.urlEncoded()) + when (filter) { + is MangaListFilter.Search -> { + append("/search?s=") + append(filter.query.urlEncoded()) append("&page=") - append(pages.toString()) + append(page.toString()) } - !tags.isNullOrEmpty() -> { - append("/$tagPrefix") - append(tag?.key.orEmpty()) + is MangaListFilter.Advanced -> { + + val tag = filter.tags.oneOrThrowIfMany() + if (filter.tags.isNotEmpty()) { + append("/$tagPrefix") + append(tag?.key.orEmpty()) + } else { + append("/$listUrl") + + } append("?page=") - append(pages.toString()) + append(page.toString()) + append("&m_orderby=") + when (filter.sortOrder) { + SortOrder.UPDATED -> append("latest") + SortOrder.RATING -> append("rating") + SortOrder.POPULARITY -> append("views") + SortOrder.NEWEST -> append("new") + else -> append("latest") + } } - else -> { + null -> { append("/$listUrl") append("?page=") - append(pages.toString()) + append(page.toString()) } } - append("&m_orderby=") - when (sortOrder) { - SortOrder.POPULARITY -> append("views") - SortOrder.UPDATED -> append("latest") - SortOrder.NEWEST -> append("new-manga") - SortOrder.ALPHABETICAL -> append("alphabet") - SortOrder.RATING -> append("rating") - } } + val doc = webClient.httpGet(url).parseHtml()