|
|
|
@ -1,5 +1,6 @@
|
|
|
|
package org.koitharu.kotatsu.parsers.site
|
|
|
|
package org.koitharu.kotatsu.parsers.site
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import androidx.collection.ArrayMap
|
|
|
|
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.PagedMangaParser
|
|
|
|
import org.koitharu.kotatsu.parsers.PagedMangaParser
|
|
|
|
@ -10,176 +11,187 @@ import java.util.*
|
|
|
|
|
|
|
|
|
|
|
|
@MangaSourceParser("MANHWA18", "Manhwa18", "en")
|
|
|
|
@MangaSourceParser("MANHWA18", "Manhwa18", "en")
|
|
|
|
class Manhwa18Parser(context: MangaLoaderContext) :
|
|
|
|
class Manhwa18Parser(context: MangaLoaderContext) :
|
|
|
|
PagedMangaParser(context, MangaSource.MANHWA18, pageSize = 20, searchPageSize = 20) {
|
|
|
|
PagedMangaParser(context, MangaSource.MANHWA18, pageSize = 20, searchPageSize = 20) {
|
|
|
|
|
|
|
|
|
|
|
|
override val configKeyDomain: ConfigKey.Domain
|
|
|
|
override val configKeyDomain: ConfigKey.Domain
|
|
|
|
get() = ConfigKey.Domain("manhwa18.net", null)
|
|
|
|
get() = ConfigKey.Domain("manhwa18.net", null)
|
|
|
|
|
|
|
|
|
|
|
|
override val sortOrders: Set<SortOrder>
|
|
|
|
override val sortOrders: Set<SortOrder>
|
|
|
|
get() = EnumSet.of(SortOrder.UPDATED, SortOrder.POPULARITY, SortOrder.ALPHABETICAL)
|
|
|
|
get() = EnumSet.of(SortOrder.UPDATED, SortOrder.POPULARITY, SortOrder.ALPHABETICAL, SortOrder.NEWEST)
|
|
|
|
|
|
|
|
|
|
|
|
override suspend fun getFavicons(): Favicons {
|
|
|
|
private val tagsMap = SuspendLazy(::parseTags)
|
|
|
|
return Favicons(
|
|
|
|
|
|
|
|
listOf(
|
|
|
|
override suspend fun getFavicons(): Favicons {
|
|
|
|
Favicon("https://${domain}/uploads/logos/logo-mini.png", 92, null),
|
|
|
|
return Favicons(
|
|
|
|
),
|
|
|
|
listOf(
|
|
|
|
domain,
|
|
|
|
Favicon("https://${domain}/uploads/logos/logo-mini.png", 92, null),
|
|
|
|
)
|
|
|
|
),
|
|
|
|
}
|
|
|
|
domain,
|
|
|
|
|
|
|
|
)
|
|
|
|
override suspend fun getDetails(manga: Manga): Manga {
|
|
|
|
}
|
|
|
|
val docs = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml()
|
|
|
|
|
|
|
|
val cardInfoElement = docs.selectFirst(".card .manga-info")
|
|
|
|
override suspend fun getDetails(manga: Manga): Manga {
|
|
|
|
val author = cardInfoElement?.selectFirst("b:contains(Author(s))")?.parent()
|
|
|
|
val docs = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml()
|
|
|
|
?.select("a.btn")
|
|
|
|
val cardInfoElement = docs.selectFirst(".card .manga-info")
|
|
|
|
?.joinToString(", ") { it.text() }
|
|
|
|
val author = cardInfoElement?.selectFirst("b:contains(Author(s))")?.parent()
|
|
|
|
val tags = cardInfoElement?.selectFirst("b:contains(Genre(s))")?.parent()
|
|
|
|
?.select("a.btn")
|
|
|
|
?.select("a.btn")
|
|
|
|
?.joinToString(", ") { it.text() }
|
|
|
|
?.mapToSet { MangaTag(it.text(), it.text().lowercase(), MangaSource.MANHWA18) }
|
|
|
|
val availableTags = tagsMap.get()
|
|
|
|
val state = cardInfoElement?.selectFirst("b:contains(Status)")?.parent()
|
|
|
|
val tags = cardInfoElement?.selectFirst("b:contains(Genre(s))")?.parent()
|
|
|
|
?.selectFirst("a.btn")
|
|
|
|
?.select("a.btn")
|
|
|
|
?.let {
|
|
|
|
?.mapNotNullToSet { availableTags[it.text().lowercase(Locale.ENGLISH)] }
|
|
|
|
when (it.text()) {
|
|
|
|
val state = cardInfoElement?.selectFirst("b:contains(Status)")?.parent()
|
|
|
|
"On going" -> MangaState.ONGOING
|
|
|
|
?.selectFirst("a.btn")
|
|
|
|
"Completed" -> MangaState.FINISHED
|
|
|
|
?.let {
|
|
|
|
else -> null
|
|
|
|
when (it.text()) {
|
|
|
|
}
|
|
|
|
"On going" -> MangaState.ONGOING
|
|
|
|
}
|
|
|
|
"Completed" -> MangaState.FINISHED
|
|
|
|
|
|
|
|
else -> null
|
|
|
|
return manga.copy(
|
|
|
|
}
|
|
|
|
altTitle = cardInfoElement?.selectFirst("b:contains(Other names)")?.parent()?.ownText()?.removePrefix(": "),
|
|
|
|
}
|
|
|
|
author = author,
|
|
|
|
|
|
|
|
description = docs.selectFirst(".series-summary .summary-content")?.html(),
|
|
|
|
return manga.copy(
|
|
|
|
tags = tags.orEmpty(),
|
|
|
|
altTitle = cardInfoElement?.selectFirst("b:contains(Other names)")?.parent()?.ownText()?.removePrefix(": "),
|
|
|
|
state = state,
|
|
|
|
author = author,
|
|
|
|
chapters = docs.select(".card-body > .list-chapters > a").asReversed().mapChapters { index, element ->
|
|
|
|
description = docs.selectFirst(".series-summary .summary-content")?.html(),
|
|
|
|
// attrAsRelativeUrl only return page url without the '/'
|
|
|
|
tags = tags.orEmpty(),
|
|
|
|
val chapterUrl = element.attrAsAbsoluteUrlOrNull("href")?.toRelativeUrl(domain)
|
|
|
|
state = state,
|
|
|
|
?: return@mapChapters null
|
|
|
|
chapters = docs.select(".card-body > .list-chapters > a").asReversed().mapChapters { index, element ->
|
|
|
|
val uploadDate = parseUploadDate(element.selectFirst(".chapter-time")?.text())
|
|
|
|
// attrAsRelativeUrl only return page url without the '/'
|
|
|
|
MangaChapter(
|
|
|
|
val chapterUrl = element.attrAsAbsoluteUrlOrNull("href")?.toRelativeUrl(domain)
|
|
|
|
id = generateUid(chapterUrl),
|
|
|
|
?: return@mapChapters null
|
|
|
|
name = element.selectFirst(".chapter-name")?.text().orEmpty(),
|
|
|
|
val uploadDate = parseUploadDate(element.selectFirst(".chapter-time")?.text())
|
|
|
|
number = index + 1,
|
|
|
|
MangaChapter(
|
|
|
|
url = chapterUrl,
|
|
|
|
id = generateUid(chapterUrl),
|
|
|
|
scanlator = null,
|
|
|
|
name = element.selectFirst(".chapter-name")?.text().orEmpty(),
|
|
|
|
uploadDate = uploadDate,
|
|
|
|
number = index + 1,
|
|
|
|
branch = null,
|
|
|
|
url = chapterUrl,
|
|
|
|
source = MangaSource.MANHWA18,
|
|
|
|
scanlator = null,
|
|
|
|
)
|
|
|
|
uploadDate = uploadDate,
|
|
|
|
},
|
|
|
|
branch = null,
|
|
|
|
)
|
|
|
|
source = MangaSource.MANHWA18,
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
},
|
|
|
|
// 7 minutes ago
|
|
|
|
)
|
|
|
|
// 5 hours ago
|
|
|
|
}
|
|
|
|
// 2 days ago
|
|
|
|
|
|
|
|
// 2 weeks ago
|
|
|
|
// 7 minutes ago
|
|
|
|
// 4 years ago
|
|
|
|
// 5 hours ago
|
|
|
|
private fun parseUploadDate(timeStr: String?): Long {
|
|
|
|
// 2 days ago
|
|
|
|
timeStr ?: return 0
|
|
|
|
// 2 weeks ago
|
|
|
|
|
|
|
|
// 4 years ago
|
|
|
|
val timeWords = timeStr.split(' ')
|
|
|
|
private fun parseUploadDate(timeStr: String?): Long {
|
|
|
|
if (timeWords.size != 3) return 0
|
|
|
|
timeStr ?: return 0
|
|
|
|
val timeWord = timeWords[1]
|
|
|
|
|
|
|
|
val timeAmount = timeWords[0].toIntOrNull() ?: return 0
|
|
|
|
val timeWords = timeStr.split(' ')
|
|
|
|
val timeUnit = when (timeWord) {
|
|
|
|
if (timeWords.size != 3) return 0
|
|
|
|
"minute", "minutes" -> Calendar.MINUTE
|
|
|
|
val timeWord = timeWords[1]
|
|
|
|
"hour", "hours" -> Calendar.HOUR
|
|
|
|
val timeAmount = timeWords[0].toIntOrNull() ?: return 0
|
|
|
|
"day", "days" -> Calendar.DAY_OF_YEAR
|
|
|
|
val timeUnit = when (timeWord) {
|
|
|
|
"week", "weeks" -> Calendar.WEEK_OF_YEAR
|
|
|
|
"minute", "minutes" -> Calendar.MINUTE
|
|
|
|
"month", "months" -> Calendar.MONTH
|
|
|
|
"hour", "hours" -> Calendar.HOUR
|
|
|
|
"year", "years" -> Calendar.YEAR
|
|
|
|
"day", "days" -> Calendar.DAY_OF_YEAR
|
|
|
|
else -> return 0
|
|
|
|
"week", "weeks" -> Calendar.WEEK_OF_YEAR
|
|
|
|
}
|
|
|
|
"month", "months" -> Calendar.MONTH
|
|
|
|
val cal = Calendar.getInstance()
|
|
|
|
"year", "years" -> Calendar.YEAR
|
|
|
|
cal.add(timeUnit, -timeAmount)
|
|
|
|
else -> return 0
|
|
|
|
return cal.time.time
|
|
|
|
}
|
|
|
|
}
|
|
|
|
val cal = Calendar.getInstance()
|
|
|
|
|
|
|
|
cal.add(timeUnit, -timeAmount)
|
|
|
|
override suspend fun getListPage(
|
|
|
|
return cal.time.time
|
|
|
|
page: Int,
|
|
|
|
}
|
|
|
|
query: String?,
|
|
|
|
|
|
|
|
tags: Set<MangaTag>?,
|
|
|
|
override suspend fun getListPage(
|
|
|
|
sortOrder: SortOrder,
|
|
|
|
page: Int,
|
|
|
|
): List<Manga> {
|
|
|
|
query: String?,
|
|
|
|
val sortQuery = when (sortOrder) {
|
|
|
|
tags: Set<MangaTag>?,
|
|
|
|
SortOrder.ALPHABETICAL -> "name"
|
|
|
|
sortOrder: SortOrder,
|
|
|
|
SortOrder.POPULARITY -> "views"
|
|
|
|
): List<Manga> {
|
|
|
|
SortOrder.UPDATED -> "last_update"
|
|
|
|
val sortQuery = when (sortOrder) {
|
|
|
|
else -> ""
|
|
|
|
SortOrder.ALPHABETICAL -> "az"
|
|
|
|
}
|
|
|
|
SortOrder.POPULARITY -> "top"
|
|
|
|
|
|
|
|
SortOrder.UPDATED -> "update"
|
|
|
|
val sortType = if (sortOrder == SortOrder.ALPHABETICAL) "ASC" else "DESC"
|
|
|
|
SortOrder.NEWEST -> "new"
|
|
|
|
val tagQuery = tags?.joinToString(",") { it.key }.orEmpty()
|
|
|
|
else -> ""
|
|
|
|
val url = buildString {
|
|
|
|
}
|
|
|
|
append("https://")
|
|
|
|
|
|
|
|
append(domain)
|
|
|
|
val tagQuery = tags?.joinToString(",") { it.key }.orEmpty()
|
|
|
|
append("/manga-list.html?listType=pagination&page=")
|
|
|
|
val url = buildString {
|
|
|
|
append(page)
|
|
|
|
append("https://")
|
|
|
|
append("&artist=&author=&group=&m_status=&name=")
|
|
|
|
append(domain)
|
|
|
|
append(query?.urlEncoded().orEmpty())
|
|
|
|
append("/tim-kiem?page=")
|
|
|
|
append("&genre=$tagQuery")
|
|
|
|
append(page)
|
|
|
|
append("&ungenre=")
|
|
|
|
if (!query.isNullOrEmpty()) {
|
|
|
|
append("&sort=")
|
|
|
|
append("&q=")
|
|
|
|
append(sortQuery)
|
|
|
|
append(query.urlEncoded())
|
|
|
|
append("&sort_type=")
|
|
|
|
}
|
|
|
|
append(sortType)
|
|
|
|
append("&accept_genres=$tagQuery")
|
|
|
|
}
|
|
|
|
append("&sort=")
|
|
|
|
|
|
|
|
append(sortQuery)
|
|
|
|
val docs = webClient.httpGet(url).parseHtml()
|
|
|
|
}
|
|
|
|
val actualPage = docs.selectFirst("ul.pagination a.active")?.text()?.toIntOrNull()
|
|
|
|
|
|
|
|
if (actualPage != page) {
|
|
|
|
val docs = webClient.httpGet(url).parseHtml()
|
|
|
|
return emptyList()
|
|
|
|
|
|
|
|
}
|
|
|
|
return docs.select(".card-body .thumb-item-flow")
|
|
|
|
|
|
|
|
.map {
|
|
|
|
return docs.select(".card-body .thumb-item-flow")
|
|
|
|
val titleElement = it.selectFirstOrThrow(".thumb_attr.series-title > a")
|
|
|
|
.map {
|
|
|
|
val absUrl = titleElement.attrAsAbsoluteUrl("href")
|
|
|
|
val titleElement = it.selectFirstOrThrow(".thumb_attr.series-title > a")
|
|
|
|
Manga(
|
|
|
|
val absUrl = titleElement.attrAsAbsoluteUrl("href")
|
|
|
|
id = generateUid(absUrl.toRelativeUrl(domain)),
|
|
|
|
Manga(
|
|
|
|
title = titleElement.text(),
|
|
|
|
id = generateUid(absUrl.toRelativeUrl(domain)),
|
|
|
|
altTitle = null,
|
|
|
|
title = titleElement.text(),
|
|
|
|
url = absUrl.toRelativeUrl(domain),
|
|
|
|
altTitle = null,
|
|
|
|
publicUrl = absUrl,
|
|
|
|
url = absUrl.toRelativeUrl(domain),
|
|
|
|
rating = RATING_UNKNOWN,
|
|
|
|
publicUrl = absUrl,
|
|
|
|
isNsfw = true,
|
|
|
|
rating = RATING_UNKNOWN,
|
|
|
|
coverUrl = it.selectFirst("div.img-in-ratio")?.attrAsAbsoluteUrl("data-bg").orEmpty(),
|
|
|
|
isNsfw = true,
|
|
|
|
tags = emptySet(),
|
|
|
|
coverUrl = it.selectFirst("div.img-in-ratio")?.attrAsAbsoluteUrl("data-bg").orEmpty(),
|
|
|
|
state = null,
|
|
|
|
tags = emptySet(),
|
|
|
|
author = null,
|
|
|
|
state = null,
|
|
|
|
largeCoverUrl = null,
|
|
|
|
author = null,
|
|
|
|
description = null,
|
|
|
|
largeCoverUrl = null,
|
|
|
|
source = MangaSource.MANHWA18,
|
|
|
|
description = null,
|
|
|
|
)
|
|
|
|
source = MangaSource.MANHWA18,
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
|
|
|
|
|
|
|
|
val chapterUrl = chapter.url.toAbsoluteUrl(domain)
|
|
|
|
override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
|
|
|
|
val doc = webClient.httpGet(chapterUrl).parseHtml()
|
|
|
|
val chapterUrl = chapter.url.toAbsoluteUrl(domain)
|
|
|
|
return doc.requireElementById("chapter-content").select("img").mapNotNull {
|
|
|
|
return webClient.httpGet(chapterUrl).parseHtml()
|
|
|
|
val url = it.attrAsRelativeUrlOrNull("data-src")
|
|
|
|
.select("div.chapter-content > img").map {
|
|
|
|
?: it.attrAsRelativeUrlOrNull("src")
|
|
|
|
val url = it.attrAsRelativeUrlOrNull("src").orEmpty()
|
|
|
|
?: return@mapNotNull null
|
|
|
|
MangaPage(
|
|
|
|
MangaPage(
|
|
|
|
id = generateUid(url),
|
|
|
|
id = generateUid(url),
|
|
|
|
url = url,
|
|
|
|
url = url,
|
|
|
|
referer = chapterUrl,
|
|
|
|
referer = chapterUrl,
|
|
|
|
preview = null,
|
|
|
|
preview = null,
|
|
|
|
source = MangaSource.MANHWA18,
|
|
|
|
source = MangaSource.MANHWA18,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
override suspend fun getTags(): Set<MangaTag> {
|
|
|
|
override suspend fun getTags(): Set<MangaTag> {
|
|
|
|
return webClient.httpGet("https://${domain}/").parseHtml().selectFirstOrThrow(".genres-menu")
|
|
|
|
return tagsMap.get().values.toSet()
|
|
|
|
.select("a.genres-item").orEmpty()
|
|
|
|
}
|
|
|
|
.mapToSet {
|
|
|
|
|
|
|
|
MangaTag(
|
|
|
|
private suspend fun parseTags(): Map<String, MangaTag> {
|
|
|
|
title = it.text(),
|
|
|
|
val doc = webClient.httpGet("https://$domain/tim-kiem?q=").parseHtml()
|
|
|
|
key = it.text().lowercase(),
|
|
|
|
val list = doc.getElementsByAttribute("data-genre-id")
|
|
|
|
source = MangaSource.MANHWA18,
|
|
|
|
if (list.isEmpty()) {
|
|
|
|
)
|
|
|
|
return emptyMap()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
val result = ArrayMap<String, MangaTag>(list.size)
|
|
|
|
|
|
|
|
for (item in list) {
|
|
|
|
|
|
|
|
val id = item.attr("data-genre-id")
|
|
|
|
|
|
|
|
val name = item.text()
|
|
|
|
|
|
|
|
result[name.lowercase(Locale.ENGLISH)] = MangaTag(
|
|
|
|
|
|
|
|
title = name.toTitleCase(Locale.ENGLISH),
|
|
|
|
|
|
|
|
key = id,
|
|
|
|
|
|
|
|
source = source,
|
|
|
|
|
|
|
|
)
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return result
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
