KotatsuApp
/
Kotatsu
2
0
Fork 0
Code Issues 124 Pull Requests Packages Projects Releases 163 Wiki Activity

UzayManga: Fix getPages (#2086)

Browse Source
fuckpdf 9 months ago committed by GitHub
parent de76ccf753
commit 705a684cc2
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 195 additions and 190 deletions
Show Stats Download Patch File Download Diff File

385
src/main/kotlin/org/koitharu/kotatsu/parsers/site/tr/UzayManga.kt
Unescape Escape View File

@ -13,193 +13,198 @@ import java.util.*
@MangaSourceParser("UZAYMANGA", "Uzay Manga", "tr") @MangaSourceParser("UZAYMANGA", "Uzay Manga", "tr")
internal class UzayManga(context: MangaLoaderContext) : internal class UzayManga(context: MangaLoaderContext) :
PagedMangaParser(context, MangaParserSource.UZAYMANGA, 25) { PagedMangaParser(context, MangaParserSource.UZAYMANGA, 25) {
override val configKeyDomain = ConfigKey.Domain("uzaymanga.com") override val configKeyDomain = ConfigKey.Domain("uzaymanga.com")
private val cdnSuffix = "cdn1.$domain"
override fun onCreateConfig(keys: MutableCollection<ConfigKey<*>>) {
override fun onCreateConfig(keys: MutableCollection<ConfigKey<*>>) { super.onCreateConfig(keys)
super.onCreateConfig(keys) keys.add(userAgentKey)
keys.add(userAgentKey) }
}
override val availableSortOrders: Set<SortOrder> = EnumSet.of(
override val availableSortOrders: Set<SortOrder> = EnumSet.of( SortOrder.ALPHABETICAL,
SortOrder.ALPHABETICAL, SortOrder.ALPHABETICAL_DESC,
SortOrder.ALPHABETICAL_DESC, SortOrder.NEWEST,
SortOrder.NEWEST, SortOrder.POPULARITY,
SortOrder.POPULARITY, SortOrder.UPDATED,
SortOrder.UPDATED, )
)
override val filterCapabilities: MangaListFilterCapabilities
override val filterCapabilities: MangaListFilterCapabilities get() = MangaListFilterCapabilities(
get() = MangaListFilterCapabilities( isSearchSupported = true,
isSearchSupported = true, isMultipleTagsSupported = true,
isMultipleTagsSupported = true, isSearchWithFiltersSupported = true,
isSearchWithFiltersSupported = true, )
)
override suspend fun getFilterOptions() = MangaListFilterOptions(
override suspend fun getFilterOptions() = MangaListFilterOptions( availableTags = fetchTags(),
availableTags = fetchTags(), availableStates = EnumSet.of(MangaState.ONGOING, MangaState.FINISHED, MangaState.ABANDONED, MangaState.PAUSED),
availableStates = EnumSet.of(MangaState.ONGOING, MangaState.FINISHED, MangaState.ABANDONED, MangaState.PAUSED), availableContentTypes = EnumSet.of(
availableContentTypes = EnumSet.of( ContentType.MANGA,
ContentType.MANGA, ContentType.MANHWA,
ContentType.MANHWA, ContentType.MANHUA,
ContentType.MANHUA, ContentType.COMICS,
ContentType.COMICS, ),
), )
)
override suspend fun getListPage(page: Int, order: SortOrder, filter: MangaListFilter): List<Manga> {
override suspend fun getListPage(page: Int, order: SortOrder, filter: MangaListFilter): List<Manga> { val url = buildString {
val url = buildString { append("https://")
append("https://") append(domain)
append(domain) append("/search")
append("/search") append("?page=")
append("?page=") append(page.toString())
append(page.toString())
if (!filter.query.isNullOrEmpty()) {
if (!filter.query.isNullOrEmpty()) { append("&search=")
append("&search=") append(filter.query.urlEncoded())
append(filter.query.urlEncoded()) }
}
if (filter.tags.isNotEmpty()) {
if (filter.tags.isNotEmpty()) { append("&categories=")
append("&categories=") filter.tags.joinTo(this, ",") { it.key }
filter.tags.joinTo(this, ",") { it.key } }
}
if (filter.states.isNotEmpty()) {
if (filter.states.isNotEmpty()) { append("&publicStatus=")
append("&publicStatus=") filter.states.oneOrThrowIfMany()?.let {
filter.states.oneOrThrowIfMany()?.let { append(
append( when (it) {
when (it) { MangaState.ONGOING -> "1"
MangaState.ONGOING -> "1" MangaState.FINISHED -> "2"
MangaState.FINISHED -> "2" MangaState.ABANDONED -> "3"
MangaState.ABANDONED -> "3" MangaState.PAUSED -> "4"
MangaState.PAUSED -> "4" else -> ""
else -> "" },
}, )
) }
} }
}
if (filter.types.isNotEmpty()) {
if (filter.types.isNotEmpty()) { append("&country=")
append("&country=") filter.types.oneOrThrowIfMany()?.let {
filter.types.oneOrThrowIfMany()?.let { append(
append( when (it) {
when (it) { ContentType.MANHUA -> "1"
ContentType.MANHUA -> "1" ContentType.MANHWA -> "2"
ContentType.MANHWA -> "2" ContentType.MANGA -> "3"
ContentType.MANGA -> "3" ContentType.COMICS -> "4"
ContentType.COMICS -> "4" else -> ""
else -> "" },
}, )
) }
} }
}
append("&order=")
append("&order=") append(
append( when (order) {
when (order) { SortOrder.ALPHABETICAL -> "1"
SortOrder.ALPHABETICAL -> "1" SortOrder.ALPHABETICAL_DESC -> "2"
SortOrder.ALPHABETICAL_DESC -> "2" SortOrder.NEWEST -> "3"
SortOrder.NEWEST -> "3" SortOrder.POPULARITY -> "4"
SortOrder.POPULARITY -> "4" SortOrder.UPDATED -> "5"
SortOrder.UPDATED -> "5" else -> "1"
else -> "1" },
}, )
) }
}
val doc = webClient.httpGet(url).parseHtml()
val doc = webClient.httpGet(url).parseHtml() return doc.select("section[aria-label='series area'] .card").map { card ->
return doc.select("section[aria-label='series area'] .card").map { card -> val href = card.selectFirstOrThrow("a").attrAsRelativeUrl("href")
val href = card.selectFirstOrThrow("a").attrAsRelativeUrl("href") Manga(
Manga( id = generateUid(href),
id = generateUid(href), title = card.selectFirst("h2")?.text().orEmpty(),
title = card.selectFirst("h2")?.text().orEmpty(), altTitles = emptySet(),
altTitles = emptySet(), url = href,
url = href, publicUrl = href.toAbsoluteUrl(domain),
publicUrl = href.toAbsoluteUrl(domain), rating = RATING_UNKNOWN,
rating = RATING_UNKNOWN, contentRating = null,
contentRating = null, coverUrl = card.selectFirst("img")?.attrAsAbsoluteUrlOrNull("src"),
coverUrl = card.selectFirst("img")?.attrAsAbsoluteUrlOrNull("src"), tags = emptySet(),
tags = emptySet(), state = null,
state = null, authors = emptySet(),
authors = emptySet(), source = source,
source = source, )
) }
} }
}
override suspend fun getDetails(manga: Manga): Manga {
override suspend fun getDetails(manga: Manga): Manga { val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml()
val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml() val statusText = doc.selectFirst("span:contains(Durum) + span")?.text().orEmpty()
val statusText = doc.selectFirst("span:contains(Durum) + span")?.text().orEmpty() return manga.copy(
return manga.copy( tags = doc.select("a[href^='search?categories']").mapToSet {
tags = doc.select("a[href^='search?categories']").mapToSet { val key = it.attr("href").substringAfter("?categories=")
val key = it.attr("href").substringAfter("?categories=") MangaTag(
MangaTag( key = key,
key = key, title = it.text(),
title = it.text(), source = source,
source = source, )
) },
}, description = doc.selectFirst("div.grid h2 + p")?.text(),
description = doc.selectFirst("div.grid h2 + p")?.text(), state = when (statusText) {
state = when (statusText) { "Devam Ediyor" -> MangaState.ONGOING
"Devam Ediyor" -> MangaState.ONGOING "Birakildi" -> MangaState.ONGOING
"Birakildi" -> MangaState.ONGOING "Tamamlandi" -> MangaState.FINISHED
"Tamamlandi" -> MangaState.FINISHED else -> null
else -> null },
}, chapters = doc.select("div.list-episode a").mapChapters(reversed = true) { i, el ->
chapters = doc.select("div.list-episode a").mapChapters(reversed = true) { i, el -> val href = el.attrAsRelativeUrl("href")
val href = el.attrAsRelativeUrl("href") val dateFormat = SimpleDateFormat("MMM d ,yyyy", Locale("tr"))
val dateFormat = SimpleDateFormat("MMM d ,yyyy", Locale("tr")) MangaChapter(
MangaChapter( id = generateUid(href),
id = generateUid(href), title = el.selectFirst("h3")?.textOrNull(),
title = el.selectFirst("h3")?.textOrNull(), number = (i + 1).toFloat(),
number = (i + 1).toFloat(), volume = 0,
volume = 0, url = href,
url = href, scanlator = null,
scanlator = null, uploadDate = dateFormat.parseSafe(el.selectFirst("span")?.text()),
uploadDate = dateFormat.parseSafe(el.selectFirst("span")?.text()), branch = null,
branch = null, source = source,
source = source, )
) },
}, )
) }
}
override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
override suspend fun getPages(chapter: MangaChapter): List<MangaPage> { val fullUrl = chapter.url.toAbsoluteUrl(domain)
val doc = webClient.httpGet(chapter.url.toAbsoluteUrl(domain)).parseHtml() val doc = webClient.httpGet(fullUrl).parseHtml()
val pageRegex = Regex("\\\\\"path\\\\\":\\\\\"([^\"]+)\\\\\"")
val script = doc.select("script").find { it.html().contains(pageRegex) }?.html() ?: return emptyList() // Yeni regex: JSON içindeki "path" değerlerini yakala
return pageRegex.findAll(script).mapNotNull { result -> val pageRegex = Regex("""\\"path\\":\\"([^\\"]+)\\"""")
result.groups[1]?.value?.let { url -> val script = doc.select("script").find { it.html().contains(pageRegex) }?.html()
MangaPage( ?: return emptyList()
id = generateUid(url),
url = "https://$cdnSuffix/upload/series/$url", return pageRegex.findAll(script).mapNotNull { result ->
preview = null, result.groups[1]?.value?.let { path ->
source = source, // Yeni CDN yapısına göre URL oluştur
) MangaPage(
} id = generateUid(path),
}.toList() url = "https://manga2.efsaneler.can.re/series/$path",
} preview = null,
source = source,
private suspend fun fetchTags(): Set<MangaTag> { )
val doc = webClient.httpGet("https://$domain/search").parseHtml() }
val script = }.toList()
doc.select("script").find { it.html().contains("self.__next_f.push([1,\"10:[\\\"\\$,\\\"section") }?.html() }
?: return emptySet()
private suspend fun fetchTags(): Set<MangaTag> {
val jsonStr = script.substringAfter("\"category\":[") val doc = webClient.httpGet("https://$domain/search").parseHtml()
.substringBefore("],\"searchParams\":{}") val script =
.replace("\\", "") doc.select("script").find { it.html().contains("self.__next_f.push([1,\"10:[\\\"\\$,\\\"section") }?.html()
?: return emptySet()
val jsonArray = JSONArray("[$jsonStr]")
return jsonArray.mapJSONToSet { jo -> val jsonStr = script.substringAfter("\"category\":[")
MangaTag( .substringBefore("],\"searchParams\":{}")
key = jo.getString("id"), .replace("\\", "")
title = jo.getString("name"),
source = source, val jsonArray = JSONArray("[$jsonStr]")
) return jsonArray.mapJSONToSet { jo ->
} MangaTag(
} key = jo.getString("id"),
} title = jo.getString("name"),
source = source,
)
}
}
}

Write Preview
Loading…
Cancel
Save