KotatsuApp
/
kotatsu-parsers
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

XoxoComics: Fixes (#2229)

Browse Source
master
Naga 7 months ago committed by GitHub
parent 185d9b6e6e
commit 86b8642456
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 242 additions and 182 deletions
Show Stats Download Patch File Download Diff File

4
.gitignore vendored
Unescape Escape View File

@ -92,3 +92,7 @@ local.properties
.idea/**/runConfigurations.xml .idea/**/runConfigurations.xml
.idea/**/AndroidProjectSystem.xml .idea/**/AndroidProjectSystem.xml
.idea/caches/deviceStreaming.xml .idea/caches/deviceStreaming.xml
/.idea/copilot.data.migration.agent.xml
/.idea/copilot.data.migration.ask.xml
/.idea/copilot.data.migration.ask2agent.xml
/.idea/copilot.data.migration.edit.xml

420
src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/en/XoxoComics.kt
Unescape Escape View File

@ -6,191 +6,247 @@ import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.sync.withLock import kotlinx.coroutines.sync.withLock
import org.koitharu.kotatsu.parsers.MangaLoaderContext import org.koitharu.kotatsu.parsers.MangaLoaderContext
import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.MangaSourceParser
import org.koitharu.kotatsu.parsers.model.* import org.koitharu.kotatsu.parsers.model.ContentRating
import org.koitharu.kotatsu.parsers.model.ContentType
import org.koitharu.kotatsu.parsers.model.Manga
import org.koitharu.kotatsu.parsers.model.MangaChapter
import org.koitharu.kotatsu.parsers.model.MangaListFilter
import org.koitharu.kotatsu.parsers.model.MangaPage
import org.koitharu.kotatsu.parsers.model.MangaParserSource
import org.koitharu.kotatsu.parsers.model.MangaState
import org.koitharu.kotatsu.parsers.model.MangaTag
import org.koitharu.kotatsu.parsers.model.RATING_UNKNOWN
import org.koitharu.kotatsu.parsers.model.SortOrder
import org.koitharu.kotatsu.parsers.site.wpcomics.WpComicsParser import org.koitharu.kotatsu.parsers.site.wpcomics.WpComicsParser
import org.koitharu.kotatsu.parsers.util.* import org.koitharu.kotatsu.parsers.util.attrAsRelativeUrl
import org.koitharu.kotatsu.parsers.Broken import org.koitharu.kotatsu.parsers.util.generateUid
import org.koitharu.kotatsu.parsers.util.host
import org.koitharu.kotatsu.parsers.util.mapChapters
import org.koitharu.kotatsu.parsers.util.mapToSet
import org.koitharu.kotatsu.parsers.util.oneOrThrowIfMany
import org.koitharu.kotatsu.parsers.util.parseHtml
import org.koitharu.kotatsu.parsers.util.parseSafe
import org.koitharu.kotatsu.parsers.util.removeSuffix
import org.koitharu.kotatsu.parsers.util.selectFirstOrThrow
import org.koitharu.kotatsu.parsers.util.textOrNull
import org.koitharu.kotatsu.parsers.util.toAbsoluteUrl
import org.koitharu.kotatsu.parsers.util.toTitleCase
import org.koitharu.kotatsu.parsers.util.urlEncoded
import java.text.SimpleDateFormat import java.text.SimpleDateFormat
import java.util.* import java.util.EnumSet
@Broken
@MangaSourceParser("XOXOCOMICS", "XoxoComics", "en", ContentType.COMICS) @MangaSourceParser("XOXOCOMICS", "XoxoComics", "en", ContentType.COMICS)
internal class XoxoComics(context: MangaLoaderContext) : internal class XoxoComics(context: MangaLoaderContext) :
WpComicsParser(context, MangaParserSource.XOXOCOMICS, "xoxocomic.com", 50) { WpComicsParser(context, MangaParserSource.XOXOCOMICS, "xoxocomic.com", 36) {
override val listUrl = "/comic-list" override val listUrl = "/comic-list"
override val datePattern = "MM/dd/yyyy" override val datePattern = "MM/dd/yyyy"
override val availableSortOrders: Set<SortOrder> = EnumSet.of( override val availableSortOrders: Set<SortOrder> = EnumSet.of(
SortOrder.UPDATED, SortOrder.UPDATED,
SortOrder.NEWEST, SortOrder.NEWEST,
SortOrder.POPULARITY, SortOrder.POPULARITY,
SortOrder.ALPHABETICAL, SortOrder.ALPHABETICAL,
) )
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)
when { when {
!filter.query.isNullOrEmpty() -> {
!filter.query.isNullOrEmpty() -> { append("/search-comic?keyword=")
append("/search-comic?keyword=") append(filter.query.urlEncoded())
append(filter.query.urlEncoded()) append("&page=")
append("&page=") append(page.toString())
append(page.toString()) }
}
else -> {
else -> { // Handle state filters
val state = filter.states.oneOrThrowIfMany()
if (filter.tags.isNotEmpty()) { val tag = filter.tags.oneOrThrowIfMany()
filter.tags.oneOrThrowIfMany()?.let {
append("/") when {
append(it.key) // Tag filtering (genre pages)
} tag != null -> {
} append("/")
append(tag.key)
filter.states.oneOrThrowIfMany()?.let { append("-comic")
append( when (order) {
when (it) { SortOrder.POPULARITY -> append("/popular")
MangaState.ONGOING -> "/ongoing" SortOrder.UPDATED -> append("/latest")
MangaState.FINISHED -> "/completed" SortOrder.NEWEST -> append("/newest")
else -> "" SortOrder.ALPHABETICAL -> append("")
}, else -> append("/latest")
) }
if (filter.tags.isEmpty()) { }
append("-comic") // State filtering (ongoing/completed)
} state != null -> {
} when (state) {
MangaState.ONGOING -> append("/ongoing-comic")
if (filter.states.isEmpty() && filter.tags.isEmpty()) { MangaState.FINISHED -> append("/completed-comic")
append(listUrl) else -> append(listUrl)
} }
when (order) {
when (order) { SortOrder.POPULARITY -> append("/popular")
SortOrder.POPULARITY -> append("/popular") SortOrder.UPDATED -> append("/latest")
SortOrder.UPDATED -> append("/latest") SortOrder.NEWEST -> append("/newest")
SortOrder.NEWEST -> append("/newest") SortOrder.ALPHABETICAL -> append("")
SortOrder.ALPHABETICAL -> append("") else -> append("/latest")
else -> append("/latest") }
} }
append("?page=") // Default listing
append(page.toString()) else -> {
} when (order) {
} SortOrder.UPDATED -> append("/comic-update")
} SortOrder.POPULARITY -> append("/popular-comic")
val doc = webClient.httpGet(url).parseHtml() SortOrder.NEWEST -> append("/new-comic")
SortOrder.ALPHABETICAL -> append(listUrl)
return doc.select("div.item, #nt_listchapter nav ul li").map { div -> else -> append("/comic-update")
val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href") }
Manga( }
id = generateUid(href), }
url = href,
publicUrl = href.toAbsoluteUrl(div.host ?: domain), append("?page=")
coverUrl = div.selectFirst("img")?.src().orEmpty(), append(page.toString())
title = div.selectFirstOrThrow("h3").text().orEmpty(), }
altTitles = emptySet(), }
rating = RATING_UNKNOWN, }
tags = emptySet(), val doc = webClient.httpGet(url).parseHtml()
authors = emptySet(),
state = null, // Handle different page layouts: popular comics (article.item), ongoing/completed (div.item), and list pages (li.row)
source = source, val elements = doc.select("div.items article.item, div.row div.item, li.row")
contentRating = if (isNsfwSource) ContentRating.ADULT else null,
) return elements.map { element ->
} // Find the main link - could be in different locations depending on page type
} val a = element.selectFirst("figure figcaption h3 a")
?: element.selectFirst("figcaption h3 a")
override suspend fun getOrCreateTagMap(): ArrayMap<String, MangaTag> = mutex.withLock { ?: element.selectFirst("h3 a")
tagCache?.let { return@withLock it } ?: element.selectFirst("a")
val doc = webClient.httpGet("https://$domain$listUrl").parseHtml() ?: throw IllegalStateException("Could not find main link in element")
val list = doc.select("div.genres ul li:not(.active)").mapNotNull { li ->
val a = li.selectFirst("a") ?: return@mapNotNull null val href = a.attrAsRelativeUrl("href")
val href = a.attr("href").removeSuffix('/').substringAfterLast('/')
MangaTag( // Handle different image structures and lazy loading
key = href, val img = element.selectFirst("img")
title = a.text(), val coverUrl = when {
source = source, img?.hasAttr("data-original") == true -> img.attr("data-original")
) img?.hasAttr("data-src") == true -> img.attr("data-src")
} img?.hasAttr("src") == true -> img.attr("src")
val result = list.associateByTo(ArrayMap(list.size)) { it.title } else -> ""
tagCache = result }.takeIf { it.isNotBlank() && !it.contains("data:image") } ?: ""
result
} val title = a.text().trim()
override suspend fun getDetails(manga: Manga): Manga = coroutineScope { Manga(
val fullUrl = manga.url.toAbsoluteUrl(domain) id = generateUid(href),
val doc = webClient.httpGet(fullUrl).parseHtml() url = href,
val chaptersDeferred = async { loadChapters(fullUrl) } publicUrl = href.toAbsoluteUrl(element.host ?: domain),
val desc = doc.selectFirstOrThrow(selectDesc).html() coverUrl = coverUrl,
val stateDiv = doc.selectFirst(selectState) title = title,
val state = stateDiv?.let { altTitles = emptySet(),
when (it.text()) { rating = RATING_UNKNOWN,
in ongoing -> MangaState.ONGOING tags = emptySet(),
in finished -> MangaState.FINISHED authors = emptySet(),
else -> null state = null,
} source = source,
} contentRating = if (isNsfwSource) ContentRating.ADULT else null,
val author = doc.body().select(selectAut).textOrNull() )
manga.copy( }
tags = doc.body().select(selectTag).mapToSet { a -> }
MangaTag(
key = a.attr("href").removeSuffix('/').substringAfterLast('/'), override suspend fun getOrCreateTagMap(): ArrayMap<String, MangaTag> = mutex.withLock {
title = a.text().toTitleCase(), tagCache?.let { return@withLock it }
source = source, val doc = webClient.httpGet("https://$domain$listUrl").parseHtml()
) val list = doc.select("div.genres ul li:not(.active)").mapNotNull { li ->
}, val a = li.selectFirst("a") ?: return@mapNotNull null
description = desc, val href = a.attr("href").removeSuffix('/').substringAfterLast('/')
authors = setOfNotNull(author), MangaTag(
state = state, key = href,
chapters = chaptersDeferred.await(), title = a.text(),
) source = source,
} )
}
private val dateFormat = SimpleDateFormat("MM/dd/yyyy", sourceLocale) val result = list.associateByTo(ArrayMap(list.size)) { it.title }
tagCache = result
private suspend fun loadChapters(baseUrl: String): List<MangaChapter> { result
val chapters = ArrayList<MangaChapter>() }
var page = 0
while (true) { override suspend fun getDetails(manga: Manga): Manga = coroutineScope {
++page val fullUrl = manga.url.toAbsoluteUrl(domain)
val doc = webClient.httpGet("$baseUrl?page=$page").parseHtml() val doc = webClient.httpGet(fullUrl).parseHtml()
doc.selectFirst("#nt_listchapter nav ul li:not(.heading)") ?: break val chaptersDeferred = async { loadChapters(fullUrl) }
chapters.addAll( val desc = doc.selectFirstOrThrow(selectDesc).html()
doc.select("#nt_listchapter nav ul li:not(.heading)").mapChapters { _, li -> val stateDiv = doc.selectFirst(selectState)
val a = li.selectFirstOrThrow("a") val state = stateDiv?.let {
val href = a.attr("href") when (it.text()) {
val dateText = li.selectFirst("div.col-xs-3")?.text() in ongoing -> MangaState.ONGOING
MangaChapter( in finished -> MangaState.FINISHED
id = generateUid(href), else -> null
title = a.text(), }
number = 0f, }
volume = 0, val author = doc.body().select(selectAut).textOrNull()
url = href, manga.copy(
scanlator = null, tags = doc.body().select(selectTag).mapToSet { a ->
uploadDate = dateFormat.parseSafe(dateText), MangaTag(
branch = null, key = a.attr("href").removeSuffix('/').substringAfterLast('/'),
source = source, title = a.text().toTitleCase(),
) source = source,
)
}, },
) description = desc,
} authors = setOfNotNull(author),
chapters.reverse() state = state,
return chapters.mapIndexed { i, x -> x.copy(volume = x.volume, number = (i + 1).toFloat()) } chapters = chaptersDeferred.await(),
} )
}
override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
val fullUrl = chapter.url.toAbsoluteUrl(domain) + "/all" private val dateFormat = SimpleDateFormat("MM/dd/yyyy", sourceLocale)
val doc = webClient.httpGet(fullUrl).parseHtml()
return doc.select(selectPage).mapNotNull { url -> private suspend fun loadChapters(baseUrl: String): List<MangaChapter> {
val img = url.src()?.toRelativeUrl(domain) ?: return@mapNotNull null val chapters = ArrayList<MangaChapter>()
val originalImage = img.replace("[", "").replace("]", "") var page = 0
MangaPage( while (true) {
id = generateUid(img), ++page
url = originalImage, val doc = webClient.httpGet("$baseUrl?page=$page").parseHtml()
preview = null, val chapterElements = doc.select("#nt_listchapter nav ul li:not(.heading)")
source = source, if (chapterElements.isEmpty()) break
)
} chapters.addAll(
} chapterElements.mapChapters { _, li ->
val a = li.selectFirstOrThrow("a")
val href = a.attr("href")
val dateText = li.selectFirst("div.col-xs-3")?.text()
MangaChapter(
id = generateUid(href),
title = a.text(),
number = 0f,
volume = 0,
url = href,
scanlator = null,
uploadDate = dateFormat.parseSafe(dateText),
branch = null,
source = source,
)
},
)
}
chapters.reverse()
return chapters.mapIndexed { i, x -> x.copy(volume = x.volume, number = (i + 1).toFloat()) }
}
override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
val fullUrl = chapter.url.toAbsoluteUrl(domain) + "/all"
val doc = webClient.httpGet(fullUrl).parseHtml()
return doc.select("img[data-original]").mapNotNull { img ->
val imgUrl = img.attr("data-original").takeIf { it.isNotBlank() } ?: return@mapNotNull null
val originalImage = imgUrl.replace("[", "").replace("]", "")
MangaPage(
id = generateUid(originalImage),
url = originalImage,
preview = null,
source = source,
)
}
}
} }

Write Preview
Loading…
Cancel
Save