diff --git a/src/en/mangahere/build.gradle b/src/en/mangahere/build.gradle index fea6cf3b5..c9a48eda8 100644 --- a/src/en/mangahere/build.gradle +++ b/src/en/mangahere/build.gradle @@ -5,8 +5,12 @@ ext { appName = 'Tachiyomi: Mangahere' pkgNameSuffix = 'en.mangahere' extClass = '.Mangahere' - extVersionCode = 7 + extVersionCode = 8 libVersion = '1.2' } +dependencies { + compileOnly project(':duktape-stub') +} + apply from: "$rootDir/common.gradle" diff --git a/src/en/mangahere/src/eu/kanade/tachiyomi/extension/en/mangahere/Mangahere.kt b/src/en/mangahere/src/eu/kanade/tachiyomi/extension/en/mangahere/Mangahere.kt index 92e8d6991..a4e82fff8 100644 --- a/src/en/mangahere/src/eu/kanade/tachiyomi/extension/en/mangahere/Mangahere.kt +++ b/src/en/mangahere/src/eu/kanade/tachiyomi/extension/en/mangahere/Mangahere.kt @@ -1,19 +1,16 @@ package eu.kanade.tachiyomi.extension.en.mangahere +import com.squareup.duktape.Duktape import eu.kanade.tachiyomi.network.GET import eu.kanade.tachiyomi.source.model.* import eu.kanade.tachiyomi.source.online.ParsedHttpSource -import okhttp3.HttpUrl -import okhttp3.Request +import okhttp3.* import org.jsoup.nodes.Document import org.jsoup.nodes.Element -import java.security.SecureRandom -import java.security.cert.X509Certificate import java.text.ParseException import java.text.SimpleDateFormat import java.util.* -import javax.net.ssl.SSLContext -import javax.net.ssl.X509TrustManager +import kotlin.collections.ArrayList class Mangahere : ParsedHttpSource() { @@ -27,233 +24,298 @@ class Mangahere : ParsedHttpSource() { override val supportsLatest = true - private val trustManager = object : X509TrustManager { - override fun getAcceptedIssuers(): Array { - return emptyArray() - } - - override fun checkClientTrusted(chain: Array, authType: String) { - } - - override fun checkServerTrusted(chain: Array, authType: String) { - } - } - - private val sslContext = SSLContext.getInstance("SSL").apply { - init(null, arrayOf(trustManager), SecureRandom()) - } - override val client = super.client.newBuilder() - .sslSocketFactory(sslContext.socketFactory, trustManager) + .cookieJar(object : CookieJar{ + override fun saveFromResponse(url: HttpUrl, cookies: MutableList) {} + override fun loadForRequest(url: HttpUrl): MutableList { + return ArrayList().apply { + add(Cookie.Builder() + .domain("www.mangahere.cc") + .path("/") + .name("isAdult") + .value("1") + .build()) } + } + + }) .build() - override fun popularMangaSelector() = "div.directory_list > ul > li" + override fun popularMangaSelector() = ".manga-list-1-list li" - override fun latestUpdatesSelector() = "div.directory_list > ul > li" + override fun latestUpdatesSelector() = ".manga-list-1-list li" override fun popularMangaRequest(page: Int): Request { - return GET("$baseUrl/directory/$page.htm?views.za", headers) + return GET("$baseUrl/directory/$page.htm", headers) } override fun latestUpdatesRequest(page: Int): Request { - return GET("$baseUrl/directory/$page.htm?last_chapter_time.za", headers) - } - - private fun mangaFromElement(query: String, element: Element): SManga { - val manga = SManga.create() - element.select(query).first().let { - manga.setUrlWithoutDomain(it.attr("href")) - manga.title = if (it.hasAttr("title")) it.attr("title") else if (it.hasAttr("rel")) it.attr("rel") else it.text() - } - return manga + return GET("$baseUrl/directory/$page.htm?latest", headers) } override fun popularMangaFromElement(element: Element): SManga { - return mangaFromElement("div.title > a", element) + val manga = SManga.create() + + val titleElement = element.select("a").first() + manga.title = titleElement.attr("title") + manga.setUrlWithoutDomain(titleElement.attr("href")) + manga.thumbnail_url = element.select("img.manga-list-1-cover") + ?.first()?.attr("src") + + return manga } override fun latestUpdatesFromElement(element: Element): SManga { return popularMangaFromElement(element) } - override fun popularMangaNextPageSelector() = "div.next-page > a.next" + override fun popularMangaNextPageSelector() = "div.pager-list-left a:last-child" - override fun latestUpdatesNextPageSelector() = "div.next-page > a.next" + override fun latestUpdatesNextPageSelector() = "div.pager-list-left a:last-child" override fun searchMangaRequest(page: Int, query: String, filters: FilterList): Request { - val url = HttpUrl.parse("$baseUrl/search.php?name_method=cw&author_method=cw&artist_method=cw&advopts=1")!!.newBuilder().addQueryParameter("name", query) - (if (filters.isEmpty()) getFilterList() else filters).forEach { filter -> - when (filter) { - is Status -> url.addQueryParameter("is_completed", arrayOf("", "1", "0")[filter.state]) - is GenreList -> filter.state.forEach { genre -> url.addQueryParameter(genre.id, genre.state.toString()) } - is TextField -> url.addQueryParameter(filter.key, filter.state) - is Type -> url.addQueryParameter("direction", arrayOf("", "rl", "lr")[filter.state]) - is OrderBy -> { - url.addQueryParameter("sort", arrayOf("name", "rating", "views", "total_chapters", "last_chapter_time")[filter.state!!.index]) - url.addQueryParameter("order", if (filter.state?.ascending == true) "az" else "za") + val url = HttpUrl.parse("$baseUrl/search")!!.newBuilder() + + filters.forEach { + when(it) { + + is TypeList -> { + url.addEncodedQueryParameter("type", types[it.values[it.state]].toString()) } + is CompletionList -> url.addEncodedQueryParameter("st", it.state.toString()) + is GenreList -> { + + val genreFilter = filters.find { it is GenreList } as GenreList? + val includeGenres = ArrayList() + val excludeGenres = ArrayList() + genreFilter?.state?.forEach { genre -> + if (genre.isIncluded()) + includeGenres.add(genre.id) + else if (genre.isExcluded()) + excludeGenres.add(genre.id) + } + + url.addEncodedQueryParameter("genres", includeGenres.joinToString(",")) + .addEncodedQueryParameter("nogenres", excludeGenres.joinToString(",")) + } + } } - url.addQueryParameter("page", page.toString()) + + url.addEncodedQueryParameter("page", page.toString()) + .addEncodedQueryParameter("title", query) + .addEncodedQueryParameter("sort", null) + .addEncodedQueryParameter("stype", 1.toString()) + .addEncodedQueryParameter("name", null) + .addEncodedQueryParameter("author_method","cw") + .addEncodedQueryParameter("author", null) + .addEncodedQueryParameter("artist_method", "cw") + .addEncodedQueryParameter("artist", null) + .addEncodedQueryParameter("rating_method","eq") + .addEncodedQueryParameter("rating",null) + .addEncodedQueryParameter("released_method","eq") + .addEncodedQueryParameter("released", null) + return GET(url.toString(), headers) } - override fun searchMangaSelector() = "div.result_search > dl:has(dt)" + override fun searchMangaSelector() = ".manga-list-4-list > li" override fun searchMangaFromElement(element: Element): SManga { - return mangaFromElement("a.manga_info", element) + val manga = SManga.create() + val titleEl = element.select(".manga-list-4-item-title > a").first() + manga.setUrlWithoutDomain(titleEl?.attr("href") ?: "") + manga.title = titleEl?.attr("title") ?: "" + return manga } - override fun searchMangaNextPageSelector() = "div.next-page > a.next" + override fun searchMangaNextPageSelector() = "div.pager-list-left a:last-child" override fun mangaDetailsParse(document: Document): SManga { - val detailElement = document.select(".manga_detail_top").first() - val infoElement = detailElement.select(".detail_topText").first() - val licensedElement = document.select(".mt10.color_ff00.mb10").first() - val manga = SManga.create() - manga.author = infoElement.select("a[href*=author/]").first()?.text() - manga.artist = infoElement.select("a[href*=artist/]").first()?.text() - manga.genre = infoElement.select("li:eq(3)").first()?.text()?.substringAfter("Genre(s):") - manga.description = infoElement.select("#show").first()?.text()?.substringBeforeLast("Show less") - manga.thumbnail_url = detailElement.select("img.img").first()?.attr("src") + manga.author = document.select(".detail-info-right-say > a")?.first()?.text() + manga.artist = "" + manga.genre = document.select(".detail-info-right-tag-list > a")?.joinToString { it.text() } + manga.description = document.select(".fullcontent")?.first()?.text() + manga.thumbnail_url = document.select("img.detail-info-cover-img")?.first() + ?.attr("src") - if (licensedElement?.text()?.contains("licensed") == true) { - manga.status = SManga.LICENSED - } else { - manga.status = infoElement.select("li:eq(6)").first()?.text().orEmpty().let { parseStatus(it) } + document.select("span.detail-info-right-title-tip")?.first()?.text()?.also { statusText -> + when { + statusText.contains("ongoing", true) -> manga.status = SManga.ONGOING + statusText.contains("completed", true) -> manga.status = SManga.COMPLETED + else -> manga.status = SManga.UNKNOWN + } } return manga } - private fun parseStatus(status: String) = when { - status.contains("Ongoing") -> SManga.ONGOING - status.contains("Completed") -> SManga.COMPLETED - else -> SManga.UNKNOWN - } - - override fun chapterListSelector() = ".detail_list > ul:not([class]) > li" + override fun chapterListSelector() = "ul.detail-main-list > li" override fun chapterFromElement(element: Element): SChapter { - val parentEl = element.select("span.left").first() - - val urlElement = parentEl.select("a").first() - - var volume = parentEl.select("span.mr6")?.first()?.text()?.trim() ?: "" - if (volume.length > 0) { - volume = " - " + volume - } - - var title = parentEl?.textNodes()?.last()?.text()?.trim() ?: "" - if (title.length > 0) { - title = " - " + title - } - val chapter = SChapter.create() - chapter.setUrlWithoutDomain(urlElement.attr("href")) - chapter.name = urlElement.text() + volume + title - chapter.date_upload = element.select("span.right").first()?.text()?.let { parseChapterDate(it) } ?: 0 + chapter.setUrlWithoutDomain(element.select("a").first().attr("href")) + chapter.name = element.select("a p.title3").first().text() + chapter.date_upload = element.select("a p.title2").first()?.text()?.let { parseChapterDate(it) } ?: 0 return chapter } private fun parseChapterDate(date: String): Long { - return if ("Today" in date) { - Calendar.getInstance().apply { - set(Calendar.HOUR_OF_DAY, 0) - set(Calendar.MINUTE, 0) - set(Calendar.SECOND, 0) - set(Calendar.MILLISECOND, 0) - }.timeInMillis - } else if ("Yesterday" in date) { - Calendar.getInstance().apply { - add(Calendar.DATE, -1) - set(Calendar.HOUR_OF_DAY, 0) - set(Calendar.MINUTE, 0) - set(Calendar.SECOND, 0) - set(Calendar.MILLISECOND, 0) - }.timeInMillis - } else { - try { - SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH).parse(date).time - } catch (e: ParseException) { - 0L - } + return try { + SimpleDateFormat("MMM dd,yyyy", Locale.ENGLISH).parse(date).time + } catch (e: ParseException) { + 0L } } override fun pageListParse(document: Document): List { - val licensedError = document.select(".mangaread_error > .mt10").first() - if (licensedError != null) { - throw Exception(licensedError.text()) - } + + val html = document.html() + val link = document.location() val pages = mutableListOf() - document.select("select.wid60").first()?.getElementsByTag("option")?.forEach { - if (!it.attr("value").contains("featured.html")) { - pages.add(Page(pages.size, "http:" + it.attr("value"))) + + val duktape = Duktape.create() + + var secretKey = extractSecretKey(html, duktape) + + val chapterIdStartLoc = html.indexOf("chapterid") + val chapterId = html.substring( + chapterIdStartLoc + 11, + html.indexOf(";", chapterIdStartLoc)).trim() + + val chapterPagesElement = document.select(".pager-list-left > span").first() + val pagesLinksElements = chapterPagesElement.select("a") + val pagesNumber = pagesLinksElements.get(pagesLinksElements.size - 2).attr("data-page").toInt() + + val pageBase = link.substring(0, link.lastIndexOf("/")) + + for (i in 1..pagesNumber){ + + val pageLink = "${pageBase}/chapterfun.ashx?cid=$chapterId&page=$i&key=$secretKey" + + var responseText = "" + + for (tr in 1..3){ + + val request = Request.Builder() + .url(pageLink) + .addHeader("Referer",link) + .addHeader("Accept","*/*") + .addHeader("Accept-Language","en-US,en;q=0.9") + .addHeader("Connection","keep-alive") + .addHeader("Host","www.mangahere.cc") + .addHeader("User-Agent", System.getProperty("http.agent") ?: "") + .addHeader("X-Requested-With","XMLHttpRequest") + .build() + + val response = client.newCall(request).execute() + responseText = response.body()!!.string() + + if (responseText.isNotEmpty()) + break + else + secretKey = "" + } + + val deobfuscatedScript = duktape.evaluate(responseText.removePrefix("eval")).toString() + + val baseLinkStartPos = deobfuscatedScript.indexOf("pix=") + 5 + val baseLinkEndPos = deobfuscatedScript.indexOf(";", baseLinkStartPos) - 1 + val baseLink = deobfuscatedScript.substring(baseLinkStartPos, baseLinkEndPos) + + val imageLinkStartPos = deobfuscatedScript.indexOf("pvalue=") + 9 + val imageLinkEndPos = deobfuscatedScript.indexOf("\"", imageLinkStartPos) + val imageLink = deobfuscatedScript.substring(imageLinkStartPos, imageLinkEndPos) + + pages.add(Page(i, "", "http:$baseLink$imageLink")) + } - pages.getOrNull(0)?.imageUrl = imageUrlParse(document) + + duktape.close() + return pages } + private fun extractSecretKey(html: String, duktape: Duktape): String { + + val secretKeyScriptLocation = html.indexOf("eval(function(p,a,c,k,e,d)") + val secretKeyScriptEndLocation = html.indexOf("", secretKeyScriptLocation) + val secretKeyScript = html.substring(secretKeyScriptLocation, secretKeyScriptEndLocation).removePrefix("eval") + + val secretKeyDeobfuscatedScript = duktape.evaluate(secretKeyScript).toString() + + val secretKeyStartLoc = secretKeyDeobfuscatedScript.indexOf("'") + val secretKeyEndLoc = secretKeyDeobfuscatedScript.indexOf(";") + + val secretKeyResultScript = secretKeyDeobfuscatedScript.substring( + secretKeyStartLoc, secretKeyEndLoc) + + return duktape.evaluate(secretKeyResultScript).toString() + + } + override fun imageUrlParse(document: Document) = document.getElementById("image").attr("src") - private class Status : Filter.TriState("Completed") - private class Genre(name: String, val id: String = "genres[$name]") : Filter.TriState(name) - private class TextField(name: String, val key: String) : Filter.Text(name) - private class Type : Filter.Select("Type", arrayOf("Any", "Japanese Manga (read from right to left)", "Korean Manhwa (read from left to right)")) - private class OrderBy : Filter.Sort("Order by", - arrayOf("Series name", "Rating", "Views", "Total chapters", "Last chapter"), - Filter.Sort.Selection(2, false)) + private class Genre(title: String, val id: Int) : Filter.TriState(title) + private class TypeList(types: Array) : Filter.Select("Type", types,0) + private class CompletionList(completions: Array) : Filter.Select("Completed series", completions,0) private class GenreList(genres: List) : Filter.Group("Genres", genres) override fun getFilterList() = FilterList( - TextField("Author", "author"), - TextField("Artist", "artist"), - Type(), - Status(), - OrderBy(), - GenreList(getGenreList()) + TypeList(types.keys.toList().sorted().toTypedArray()), + CompletionList(completions), + GenreList(genres) ) - // [...document.querySelectorAll("select[id^='genres'")].map((el,i) => `Genre("${el.nextSibling.nextSibling.textContent.trim()}", "${el.getAttribute('name')}")`).join(',\n') - // http://www.mangahere.co/advsearch.htm - private fun getGenreList() = listOf( - Genre("Action"), - Genre("Adventure"), - Genre("Comedy"), - Genre("Doujinshi"), - Genre("Drama"), - Genre("Ecchi"), - Genre("Fantasy"), - Genre("Gender Bender"), - Genre("Harem"), - Genre("Historical"), - Genre("Horror"), - Genre("Josei"), - Genre("Martial Arts"), - Genre("Mature"), - Genre("Mecha"), - Genre("Mystery"), - Genre("One Shot"), - Genre("Psychological"), - Genre("Romance"), - Genre("School Life"), - Genre("Sci-fi"), - Genre("Seinen"), - Genre("Shoujo"), - Genre("Shoujo Ai"), - Genre("Shounen"), - Genre("Shounen Ai"), - Genre("Slice of Life"), - Genre("Sports"), - Genre("Supernatural"), - Genre("Tragedy"), - Genre("Yaoi"), - Genre("Yuri") + private val types = hashMapOf( + "Japanese Manga" to 1, + "Korean Manhwa" to 2, + "Other Manga" to 4, + "Any" to 0 + ) + + private val completions = arrayOf("Either","No","Yes") + + private val genres = arrayListOf( + Genre("Action", 1), + Genre("Adventure", 2), + Genre("Comedy", 3), + Genre("Fantasy", 4), + Genre("Historical", 5), + Genre("Horror", 6), + Genre("Martial Arts", 7), + Genre("Mystery", 8), + Genre("Romance", 9), + Genre("Shounen Ai", 10), + Genre("Supernatural", 11), + Genre("Drama", 12), + Genre("Shounen", 13), + Genre("School Life", 14), + Genre("Shoujo", 15), + Genre("Gender Bender", 16), + Genre("Josei", 17), + Genre("Psychological", 18), + Genre("Seinen", 19), + Genre("Slice of Life", 20), + Genre("Sci-fi", 21), + Genre("Ecchi", 22), + Genre("Harem", 23), + Genre("Shoujo Ai", 24), + Genre("Yuri", 25), + Genre("Mature", 26), + Genre("Tragedy", 27), + Genre("Yaoi", 28), + Genre("Doujinshi", 29), + Genre("Sports", 30), + Genre("Adult", 31), + Genre("One Shot", 32), + Genre("Smut", 33), + Genre("Mecha", 34), + Genre("Shotacon", 35), + Genre("Lolicon", 36) ) } \ No newline at end of file