|
|
|
@ -7,198 +7,199 @@ import org.koitharu.kotatsu.parsers.config.ConfigKey
|
|
|
|
import org.koitharu.kotatsu.parsers.core.PagedMangaParser
|
|
|
|
import org.koitharu.kotatsu.parsers.core.PagedMangaParser
|
|
|
|
import org.koitharu.kotatsu.parsers.model.*
|
|
|
|
import org.koitharu.kotatsu.parsers.model.*
|
|
|
|
import org.koitharu.kotatsu.parsers.util.*
|
|
|
|
import org.koitharu.kotatsu.parsers.util.*
|
|
|
|
import org.koitharu.kotatsu.parsers.util.json.*
|
|
|
|
import org.koitharu.kotatsu.parsers.util.json.mapJSONToSet
|
|
|
|
import java.text.SimpleDateFormat
|
|
|
|
import java.text.SimpleDateFormat
|
|
|
|
import java.util.*
|
|
|
|
import java.util.*
|
|
|
|
|
|
|
|
|
|
|
|
@MangaSourceParser("TENSHIMANGA", "Tenshi Manga", "tr")
|
|
|
|
@MangaSourceParser("TENSHIMANGA", "Tenshi Manga", "tr")
|
|
|
|
internal class TenshiManga(context: MangaLoaderContext):
|
|
|
|
internal class TenshiManga(context: MangaLoaderContext) :
|
|
|
|
PagedMangaParser(context, MangaParserSource.TENSHIMANGA, 25) {
|
|
|
|
PagedMangaParser(context, MangaParserSource.TENSHIMANGA, 25) {
|
|
|
|
|
|
|
|
|
|
|
|
override val configKeyDomain = ConfigKey.Domain("tenshimanga.com")
|
|
|
|
override val configKeyDomain = ConfigKey.Domain("tenshimanga.com")
|
|
|
|
private val cdnSuffix = "cdn1.$domain"
|
|
|
|
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.selectFirstOrThrow("h3").text(),
|
|
|
|
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 = el.selectFirst("span")?.text()?.let { dateFormat.tryParse(it) } ?: 0L,
|
|
|
|
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 doc = webClient.httpGet(chapter.url.toAbsoluteUrl(domain)).parseHtml()
|
|
|
|
val doc = webClient.httpGet(chapter.url.toAbsoluteUrl(domain)).parseHtml()
|
|
|
|
val pageRegex = Regex("\\\\\"path\\\\\":\\\\\"([^\"]+)\\\\\"")
|
|
|
|
val pageRegex = Regex("\\\\\"path\\\\\":\\\\\"([^\"]+)\\\\\"")
|
|
|
|
val script = doc.select("script").find { it.html().contains(pageRegex) }?.html() ?: return emptyList()
|
|
|
|
val script = doc.select("script").find { it.html().contains(pageRegex) }?.html() ?: return emptyList()
|
|
|
|
return pageRegex.findAll(script).mapNotNull { result ->
|
|
|
|
return pageRegex.findAll(script).mapNotNull { result ->
|
|
|
|
result.groups[1]?.value?.let { url ->
|
|
|
|
result.groups[1]?.value?.let { url ->
|
|
|
|
MangaPage(
|
|
|
|
MangaPage(
|
|
|
|
id = generateUid(url),
|
|
|
|
id = generateUid(url),
|
|
|
|
url = "https://$cdnSuffix/upload/series/$url",
|
|
|
|
url = "https://$cdnSuffix/upload/series/$url",
|
|
|
|
preview = null,
|
|
|
|
preview = null,
|
|
|
|
source = source,
|
|
|
|
source = source,
|
|
|
|
)
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}.toList()
|
|
|
|
}.toList()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
private suspend fun fetchTags(): Set<MangaTag> {
|
|
|
|
private suspend fun fetchTags(): Set<MangaTag> {
|
|
|
|
val doc = webClient.httpGet("https://$domain/search").parseHtml()
|
|
|
|
val doc = webClient.httpGet("https://$domain/search").parseHtml()
|
|
|
|
val script = doc.select("script").find { it.html().contains("self.__next_f.push([1,\"10:[\\\"\\$,\\\"section") }?.html()
|
|
|
|
val script =
|
|
|
|
?: return emptySet()
|
|
|
|
doc.select("script").find { it.html().contains("self.__next_f.push([1,\"10:[\\\"\\$,\\\"section") }?.html()
|
|
|
|
|
|
|
|
?: return emptySet()
|
|
|
|
val jsonStr = script.substringAfter("\"category\":[")
|
|
|
|
|
|
|
|
.substringBefore("],\"searchParams\":{}")
|
|
|
|
val jsonStr = script.substringAfter("\"category\":[")
|
|
|
|
.replace("\\", "")
|
|
|
|
.substringBefore("],\"searchParams\":{}")
|
|
|
|
|
|
|
|
.replace("\\", "")
|
|
|
|
val jsonArray = JSONArray("[$jsonStr]")
|
|
|
|
|
|
|
|
return jsonArray.mapJSONToSet { jo ->
|
|
|
|
val jsonArray = JSONArray("[$jsonStr]")
|
|
|
|
MangaTag(
|
|
|
|
return jsonArray.mapJSONToSet { jo ->
|
|
|
|
key = jo.getString("id"),
|
|
|
|
MangaTag(
|
|
|
|
title = jo.getString("name"),
|
|
|
|
key = jo.getString("id"),
|
|
|
|
source = source
|
|
|
|
title = jo.getString("name"),
|
|
|
|
)
|
|
|
|
source = source,
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
