From 8dda3a575d6279a9ce332ec1663e51e8ff18de8f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Diego=20Pe=C3=B1a=20Y=20Lillo?=
 <80992641+Diegopyl1209@users.noreply.github.com>
Date: Thu, 22 Sep 2022 21:44:14 -0300
Subject: [PATCH] Fixes [JkAnime] (#883)

---
 src/es/jkanime/build.gradle                   |   2 +-
 .../animeextension/es/jkanime/Jkanime.kt      | 234 +++++-------------
 .../es/jkanime/extractors/JkanimeExtractor.kt |  41 +++
 3 files changed, 98 insertions(+), 179 deletions(-)
 create mode 100644 src/es/jkanime/src/eu/kanade/tachiyomi/animeextension/es/jkanime/extractors/JkanimeExtractor.kt

diff --git a/src/es/jkanime/build.gradle b/src/es/jkanime/build.gradle
index e4dd1c856..7c7784d70 100644
--- a/src/es/jkanime/build.gradle
+++ b/src/es/jkanime/build.gradle
@@ -5,7 +5,7 @@ ext {
     extName = 'Jkanime'
     pkgNameSuffix = 'es.jkanime'
     extClass = '.Jkanime'
-    extVersionCode = 7
+    extVersionCode = 8
     libVersion = '13'
 }
 
diff --git a/src/es/jkanime/src/eu/kanade/tachiyomi/animeextension/es/jkanime/Jkanime.kt b/src/es/jkanime/src/eu/kanade/tachiyomi/animeextension/es/jkanime/Jkanime.kt
index fc2695bdc..2a7f79386 100644
--- a/src/es/jkanime/src/eu/kanade/tachiyomi/animeextension/es/jkanime/Jkanime.kt
+++ b/src/es/jkanime/src/eu/kanade/tachiyomi/animeextension/es/jkanime/Jkanime.kt
@@ -2,10 +2,10 @@ package eu.kanade.tachiyomi.animeextension.es.jkanime
 
 import android.app.Application
 import android.content.SharedPreferences
-import android.util.Log
 import androidx.preference.ListPreference
 import androidx.preference.PreferenceScreen
 import eu.kanade.tachiyomi.animeextension.es.jkanime.extractors.FembedExtractor
+import eu.kanade.tachiyomi.animeextension.es.jkanime.extractors.JkanimeExtractor
 import eu.kanade.tachiyomi.animeextension.es.jkanime.extractors.OkruExtractor
 import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
 import eu.kanade.tachiyomi.animesource.model.AnimeFilter
@@ -20,8 +20,6 @@ import eu.kanade.tachiyomi.util.asJsoup
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.Response
-import org.jsoup.Connection
-import org.jsoup.Jsoup
 import org.jsoup.nodes.Document
 import org.jsoup.nodes.Element
 import uy.kohesive.injekt.Injekt
@@ -46,17 +44,15 @@ class Jkanime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     override fun popularAnimeSelector(): String = "div.col-lg-12 div.list"
 
-    override fun popularAnimeRequest(page: Int): Request = GET("https://jkanime.net/top/")
+    override fun popularAnimeRequest(page: Int): Request = GET("$baseUrl/top/")
 
     override fun popularAnimeFromElement(element: Element): SAnime {
-        val anime = SAnime.create()
-        anime.setUrlWithoutDomain(
-            element.select("div#conb a").attr("href")
-        )
-        anime.title = element.select("div#conb a").attr("title")
-        anime.thumbnail_url = element.select("div#conb a img").attr("src")
-        anime.description = element.select("div#conb div#animinfo p").text()
-        return anime
+        return SAnime.create().apply {
+            title = element.select("div#conb a").attr("title")
+            thumbnail_url = element.select("div#conb a img").attr("src")
+            description = element.select("div#conb div#animinfo p").text()
+            setUrlWithoutDomain(element.select("div#conb a").attr("href"))
+        }
     }
 
     override fun popularAnimeNextPageSelector(): String = "uwu"
@@ -67,55 +63,17 @@ class Jkanime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         val pageBody = response.asJsoup()
         val animeId = pageBody.select("div.anime__details__text div.anime__details__title div#guardar-anime.btn.btn-light.btn-sm.ml-2")
             .attr("data-anime")
+        val lastEp = client.newCall(GET("$baseUrl/ajax/last_episode/$animeId/")).execute().asJsoup().body().text()
+            .substringAfter("number\":\"").substringBefore("\"").toInt()
 
-        val pageNumber = pageBody.select("div.anime__pagination a")
-        val lastPage = pageNumber.last()?.attr("href")
-            ?.replace("#pag", "")
-        val firstPage = pageNumber.first()?.attr("href")
-            ?.replace("#pag", "")
-        Log.i("bruh", "ULTIMA: $lastPage")
-
-        if (firstPage != lastPage) {
-            var checkLast = 0
-            for (i in 1 until lastPage?.toInt()!!) {
-                Log.i("bruh", "aaa")
-                for (j in 1..12) {
-                    // Log.i("bruh", (j + checkLast).toString())
-                    val episode = SEpisode.create().apply {
-                        episode_number = (j + checkLast).toFloat()
-                        name = "Episodio ${j + checkLast}"
-                    }
-                    episode.setUrlWithoutDomain("$episodeLink/${j + checkLast}")
-                    episodes.add(episode)
-                }
-                checkLast += 12
-            }
-            Jsoup.connect("https://jkanime.net/ajax/pagination_episodes/$animeId/$lastPage").get()
-                .body().select("body").text().replace("}]", "").split("}").forEach { json ->
-                    val number = json.substringAfter("\"number\":\"").substringBefore("\"")
-                    Log.i("bruh", number)
-                    val episode = SEpisode.create().apply {
-                        episode_number = number.toFloat()
-                        name = "Episodio $number"
-                    }
-                    episode.setUrlWithoutDomain("$episodeLink/$number")
-                    episodes.add(episode)
-                }
+        for (i in 1..lastEp) {
+            val episode = SEpisode.create()
+            episode.setUrlWithoutDomain("$episodeLink/$i")
+            episode.name = "Episodio $i"
+            episode.episode_number = i.toFloat()
+            episodes.add(episode)
         }
 
-        if (firstPage == lastPage) {
-            Jsoup.connect("https://jkanime.net/ajax/pagination_episodes/$animeId/$lastPage").get()
-                .body().select("body").text().replace("}]", "").split("}").forEach { json ->
-                    val number = json.substringAfter("\"number\":\"").substringBefore("\"")
-                    Log.i("bruh", number)
-                    val episode = SEpisode.create().apply {
-                        episode_number = number.toFloat()
-                        name = "Episodio $number"
-                    }
-                    episode.setUrlWithoutDomain("$episodeLink/$number")
-                    episodes.add(episode)
-                }
-        }
         return episodes.reversed()
     }
 
@@ -125,100 +83,47 @@ class Jkanime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     override fun videoListParse(response: Response): List<Video> {
         val document = response.asJsoup()
-        val episodeLink = response.request.url.toString()
         val videos = mutableListOf<Video>()
         document.select("div.col-lg-12.rounded.bg-servers.text-white.p-3.mt-2 a").forEach { it ->
-            val server = it.text()
             val serverId = it.attr("data-id")
-            document.select("script").forEach { script ->
-                if (script.data().contains("var video = [];")) {
-                    val url = (
-                        baseUrl + script.data().substringAfter("video[$serverId] = '<iframe class=\"player_conte\" src=\"")
-                            .substringBefore("\"")
-                        )
-                        .replace("$baseUrl/jkfembed.php?u=", "https://embedsito.com/v/")
-                        .replace("$baseUrl/jkokru.php?u=", "http://ok.ru/videoembed/")
-                        .replace("$baseUrl/jkvmixdrop.php?u=", "https://mixdrop.co/e/")
-                        .replace("$baseUrl/jk.php?u=", "$baseUrl/")
-                    if (url.contains("um2")) {
-                        val doc = Jsoup.connect(url).referrer(episodeLink).get()
-                        val dataKey = doc.select("form input[value]").attr("value")
-                        Jsoup.connect("$baseUrl/gsplay/redirect_post.php").headers(
-                            mapOf(
-                                "Host" to "jkanime.net",
-                                "Accept" to "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
-                                "Accept-Language" to "en-US,en;q=0.5",
-                                "Referer" to url,
-                                "Content-Type" to "application/x-www-form-urlencoded",
-                                "Origin" to "https://jkanime.net",
-                                "DNT" to "1",
-                                "Connection" to "keep-alive",
-                                "Upgrade-Insecure-Requests" to "1",
-                                "Sec-Fetch-Dest" to "iframe",
-                                "Sec-Fetch-Mode" to "navigate",
-                                "Sec-Fetch-Site" to "same-origin",
-                                "TE" to "trailers",
-                                "Pragma" to "no-cache",
-                                "Cache-Control" to "no-cache",
-                            )
-                        ).data(mapOf("data" to dataKey)).method(Connection.Method.POST).followRedirects(false)
-                            .execute().headers("location").forEach { loc ->
-                                val postkey = loc.replace("/gsplay/player.html#", "")
-                                val nozomitext = Jsoup.connect("https://jkanime.net/gsplay/api.php").method(Connection.Method.POST).data("v", postkey).ignoreContentType(true).execute().body()
-                                nozomitext.toString().split("}").forEach { file ->
-                                    val nozomiUrl = file.substringAfter("\"file\":\"").substringBefore("\"").replace("\\", "")
-                                    if (nozomiUrl.isNotBlank() && !nozomiUrl.contains("{")) {
-                                        videos.add(Video(nozomiUrl, server, nozomiUrl))
-                                    }
-                                }
-                            }
-                    }
+            val scriptServers = document.selectFirst("script:containsData(var video = [];)")
+            val url = scriptServers.data().substringAfter("video[$serverId] = '<iframe class=\"player_conte\" src=\"")
+                .substringBefore("\"")
+                .replace("/jkfembed.php?u=", "https://embedsito.com/v/")
+                .replace("/jkokru.php?u=", "http://ok.ru/videoembed/")
+                .replace("/jkvmixdrop.php?u=", "https://mixdrop.co/e/")
+                .replace("/jk.php?u=", "$baseUrl/")
 
-                    when {
-                        "embedsito" in url -> FembedExtractor().videosFromUrl(url).forEach { videos.add(it) }
-                        "ok" in url -> OkruExtractor(client).videosFromUrl(url).forEach { videos.add(it) }
-                        "stream/jkmedia" in url -> videos.add(Video(url, "Xtreme S", url))
-                        "um.php" in url -> videos.add(JkanimeExtractor().videoFromUrl(url, server))
-                    }
-                }
+            when {
+                "embedsito" in url -> FembedExtractor().videosFromUrl(url).forEach { videos.add(it) }
+                "ok" in url -> OkruExtractor(client).videosFromUrl(url).forEach { videos.add(it) }
+                "stream/jkmedia" in url -> videos.add(Video(url, "Xtreme S", url))
+                "um2.php" in url -> JkanimeExtractor(client).getNozomiFromUrl(baseUrl + url).let { videos.add(it) }
+                "um.php" in url -> JkanimeExtractor(client).getDesuFromUrl(baseUrl + url).let { videos.add(it) }
             }
         }
         return videos
     }
 
-    private class JkanimeExtractor() {
-        fun videoFromUrl(url: String, server: String): Video {
-            var url1 = ""
-            Jsoup.connect(url).get().body().select("script").forEach {
-                if (it.data().contains("var parts = {")) {
-                    url1 = it.data().substringAfter("url: '").substringBefore("'")
-                }
-            }
-            return Video(url1, server, url1)
-        }
-    }
-
     override fun videoListSelector() = throw Exception("not used")
-
     override fun videoUrlParse(document: Document) = throw Exception("not used")
-
     override fun videoFromElement(element: Element) = throw Exception("not used")
 
-    override fun List<Video>.sort(): List<Video> {
-        return try {
-            val videoSorted = this.sortedWith(
-                compareBy<Video> { it.quality.replace("[0-9]".toRegex(), "") }.thenByDescending { getNumberFromString(it.quality) }
-            ).toTypedArray()
-            val userPreferredQuality = preferences.getString("preferred_quality", "Nozomi")
-            val preferredIdx = videoSorted.indexOfFirst { x -> x.quality == userPreferredQuality }
-            if (preferredIdx != -1) {
-                videoSorted.drop(preferredIdx + 1)
-                videoSorted[0] = videoSorted[preferredIdx]
+    private fun List<Video>.sortIfContains(item: String): List<Video> {
+        val newList = mutableListOf<Video>()
+        for (video in this) {
+            if (item in video.quality) {
+                newList.add(0, video)
+            } else {
+                newList.add(video)
             }
-            videoSorted.toList()
-        } catch (e: Exception) {
-            this
         }
+        return newList
+    }
+
+    override fun List<Video>.sort(): List<Video> {
+        val quality = preferences.getString("preferred_quality", "Nozomi")!!
+        return sortIfContains(quality)
     }
 
     private fun getNumberFromString(epsStr: String): String {
@@ -232,62 +137,35 @@ class Jkanime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         return when {
             query.isNotBlank() -> GET("$baseUrl/buscar/$query/$page/?filtro=fecha&tipo=none&estado=none&orden=desc", headers)
             genreFilter.state != 0 -> GET("$baseUrl/genero/${genreFilter.toUriPart()}/$page")
-            else -> GET("$baseUrl/directorio/$page/?filtro=fecha&tipo=none&estado=none&fecha=none&temporada=none&orden=desc")
+            else -> latestUpdatesRequest(page)
         }
     }
 
-    override fun searchAnimeSelector(): String = ".anime__page__content #botones ~ .row"
-
     override fun searchAnimeParse(response: Response): AnimesPage {
-        return parseSearchJson(response)
-        // return super.searchAnimeParse(response)
-    }
-
-    private fun parseSearchJson(jsonLine: Response): AnimesPage {
-        val animeList = mutableListOf<SAnime>()
-        val document = jsonLine.asJsoup()
+        val document = response.asJsoup()
         val hasNextPage = document.select("section.contenido.spad div.container div.navigation a.nav-next").any()
-        var isSearchLayer = document.select(".col-lg-2.col-md-6.col-sm-6").any()
-        val isFilterLayer = document.select(".card.mb-3.custom_item2").any()
-        if (isSearchLayer) {
-            document.select(".col-lg-2.col-md-6.col-sm-6").forEach { animeData ->
+        val isSearch = document.select(".col-lg-2.col-md-6.col-sm-6").any()
+        val animeList = if (isSearch) {
+            document.select(".col-lg-2.col-md-6.col-sm-6").map { animeData ->
                 val anime = SAnime.create()
                 anime.title = animeData.select("div.anime__item #ainfo div.title").html()
                 anime.thumbnail_url = animeData.select("div.anime__item a div.anime__item__pic").attr("data-setbg")
                 anime.setUrlWithoutDomain(animeData.select("div.anime__item a").attr("href"))
                 anime.status = parseStatus(animeData.select("div.anime__item div.anime__item__text ul li:nth-child(1)").html())
-                val tags = animeData.select("div.anime__item div.anime__item__text ul li").joinToString { it.text() }
-                anime.genre = tags
-                animeList.add(anime)
+                anime.genre = animeData.select("div.anime__item div.anime__item__text ul li").joinToString { it.text() }
+                anime
             }
-        } else if (isFilterLayer) {
-            document.select(".card.mb-3.custom_item2").forEach { animeData ->
-                val anime = SAnime.create()
-                anime.title = animeData.select("div.row div.col-md-7 div.card-body h5.card-title a").html()
-                anime.thumbnail_url = animeData.select("div.row div.custom_thumb2 a img").attr("src")
-                anime.setUrlWithoutDomain(animeData.select("div.row div.col-md-7 div.card-body h5.card-title a").attr("href"))
-                anime.status = parseStatus(animeData.select("div.row div.col-md-7 div.card-body div.card-info p.card-status").text())
-                val tags = animeData.select("div.row div.col-md-7 div.card-body div.card-info p").joinToString { it.text() }
-                anime.genre = tags
-                anime.description = animeData.select("div.row div.col-md-7 div.card-body p.synopsis").text()
-                animeList.add(anime)
+        } else { // is filtered
+            document.select(".card.mb-3.custom_item2").map { animeData ->
+                latestUpdatesFromElement(animeData)
             }
         }
         return AnimesPage(animeList, hasNextPage)
     }
 
-    override fun searchAnimeFromElement(element: Element): SAnime {
-        val anime = SAnime.create()
-        anime.setUrlWithoutDomain(
-            element.select("div.anime__item a").attr("href")
-        )
-        anime.title = element.select("div.anime__item div#ainfo div.title").text()
-        anime.thumbnail_url = element.select("div.anime__item a div").attr("data-setbg")
-        anime.description = element.select("div.anime__item#ainfo p").text()
-        return anime
-    }
-
-    override fun searchAnimeNextPageSelector(): String = popularAnimeNextPageSelector()
+    override fun searchAnimeFromElement(element: Element): SAnime = throw Exception("not used")
+    override fun searchAnimeNextPageSelector(): String = throw Exception("not used")
+    override fun searchAnimeSelector(): String = throw Exception("not used")
 
     override fun animeDetailsParse(document: Document): SAnime {
         val anime = SAnime.create()
@@ -332,7 +210,7 @@ class Jkanime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         return anime
     }
 
-    override fun latestUpdatesRequest(page: Int): Request = GET("https://jkanime.net/directorio/$page/?filtro=fecha&tipo=none&estado=none&fecha=none&temporada=none&orden=desc")
+    override fun latestUpdatesRequest(page: Int): Request = GET("$baseUrl/directorio/$page/desc/")
 
     override fun latestUpdatesSelector(): String = "div.card.mb-3.custom_item2"
 
diff --git a/src/es/jkanime/src/eu/kanade/tachiyomi/animeextension/es/jkanime/extractors/JkanimeExtractor.kt b/src/es/jkanime/src/eu/kanade/tachiyomi/animeextension/es/jkanime/extractors/JkanimeExtractor.kt
new file mode 100644
index 000000000..02e7afc5d
--- /dev/null
+++ b/src/es/jkanime/src/eu/kanade/tachiyomi/animeextension/es/jkanime/extractors/JkanimeExtractor.kt
@@ -0,0 +1,41 @@
+package eu.kanade.tachiyomi.animeextension.es.jkanime.extractors
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.POST
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.Headers
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.OkHttpClient
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.json.JSONObject
+
+class JkanimeExtractor(
+    private val client: OkHttpClient
+) {
+
+    fun getNozomiFromUrl(url: String): Video {
+        val dataKeyHeaders = Headers.Builder().add("Referer", url).build()
+        val doc = client.newCall(GET(url, dataKeyHeaders)).execute().asJsoup()
+        val dataKey = doc.select("form input[value]").attr("value")
+
+        val gsplayBody = "data=$dataKey".toRequestBody("application/x-www-form-urlencoded".toMediaTypeOrNull())
+
+        val location = client.newCall(POST("https://jkanime.net/gsplay/redirect_post.php", dataKeyHeaders, gsplayBody)).execute().request.url.toString()
+        val postKey = location.substringAfter("player.html#")
+
+        val nozomiBody = "v=$postKey".toRequestBody("application/x-www-form-urlencoded".toMediaTypeOrNull())
+        val nozomiResponse = client.newCall(POST("https://jkanime.net/gsplay/api.php", body = nozomiBody)).execute().body!!.string()
+
+        val nozomiUrl = JSONObject(nozomiResponse).getString("file")
+
+        return Video(nozomiUrl, "Nozomi", nozomiUrl)
+    }
+
+    fun getDesuFromUrl(url: String): Video {
+        val document = client.newCall(GET(url)).execute().asJsoup()
+        val script = document.selectFirst("script:containsData(var parts = {)").data()
+        val streamUrl = script.substringAfter("url: '").substringBefore("'")
+        return Video(streamUrl, "Desu", streamUrl)
+    }
+}