INSANEMODE/aniyomi-extensions-backup
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(pt/vizer): Update baseUrl, fix episode list, add WarezCDN extractor (#3036)

Browse Source
This commit is contained in:
Claudemirovsky 2024-03-10 18:57:47 -03:00 committed by GitHub
parent d6da1c973c
commit b85bc9a5f7
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
4 changed files with 125 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/pt/vizer/build.gradle
View File

@ -1,7 +1,7 @@
ext {
extName = 'Vizer.tv'
extClass = '.Vizer'
extVersionCode = 13
extVersionCode = 14
isNsfw = true
}
@ -10,4 +10,4 @@ apply from: "$rootDir/common.gradle"
dependencies {
implementation(project(':lib:mixdrop-extractor'))
implementation(project(':lib:streamtape-extractor'))
}
}

68
src/pt/vizer/src/eu/kanade/tachiyomi/animeextension/pt/vizer/Vizer.kt
View File

@ -5,11 +5,12 @@ import androidx.preference.ListPreference
import androidx.preference.PreferenceScreen
import eu.kanade.tachiyomi.animeextension.pt.vizer.VizerFilters.FilterSearchParams
import eu.kanade.tachiyomi.animeextension.pt.vizer.dto.EpisodeListDto
import eu.kanade.tachiyomi.animeextension.pt.vizer.dto.PlayersDto
import eu.kanade.tachiyomi.animeextension.pt.vizer.dto.HostersDto
import eu.kanade.tachiyomi.animeextension.pt.vizer.dto.SearchItemDto
import eu.kanade.tachiyomi.animeextension.pt.vizer.dto.SearchResultDto
import eu.kanade.tachiyomi.animeextension.pt.vizer.dto.VideoDto
import eu.kanade.tachiyomi.animeextension.pt.vizer.dto.VideoLanguagesDto
import eu.kanade.tachiyomi.animeextension.pt.vizer.dto.VideoListDto
import eu.kanade.tachiyomi.animeextension.pt.vizer.extractors.WarezExtractor
import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
import eu.kanade.tachiyomi.animesource.model.AnimesPage
@ -24,7 +25,6 @@ import eu.kanade.tachiyomi.network.POST
import eu.kanade.tachiyomi.network.awaitSuccess
import eu.kanade.tachiyomi.util.asJsoup
import eu.kanade.tachiyomi.util.parseAs
import kotlinx.serialization.json.Json
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.Request
@ -33,20 +33,19 @@ import okhttp3.Response
import org.jsoup.nodes.Element
import uy.kohesive.injekt.Injekt
import uy.kohesive.injekt.api.get
import uy.kohesive.injekt.injectLazy
class Vizer : ConfigurableAnimeSource, AnimeHttpSource() {
override val name = "Vizer.tv"
override val baseUrl = "https://vizer.tv"
override val baseUrl = "https://vizertv.in"
private val apiUrl = "$baseUrl/includes/ajax"
override val lang = "pt-BR"
override val supportsLatest = true
private val json: Json by injectLazy()
override fun headersBuilder() = super.headersBuilder().add("Referer", "$baseUrl/")
private val preferences by lazy {
Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
@ -65,7 +64,7 @@ class Vizer : ConfigurableAnimeSource, AnimeHttpSource() {
override fun popularAnimeParse(response: Response): AnimesPage {
val result = response.parseAs<SearchResultDto>()
val animes = result.list.map(::animeFromObject)
val animes = result.items.values.map(::animeFromObject)
val hasNext = result.quantity == 35
return AnimesPage(animes, hasNext)
}
@ -89,7 +88,7 @@ class Vizer : ConfigurableAnimeSource, AnimeHttpSource() {
override fun latestUpdatesParse(response: Response): AnimesPage {
val parsedData = response.parseAs<SearchResultDto>()
val animes = parsedData.list.map(::animeFromObject)
val animes = parsedData.items.values.map(::animeFromObject)
return AnimesPage(animes, false)
}
@ -165,6 +164,7 @@ class Vizer : ConfigurableAnimeSource, AnimeHttpSource() {
val sname = seasonElement.text()
val response = client.newCall(apiRequest("getEpisodes=$id")).execute()
val episodes = response.parseAs<EpisodeListDto>().episodes
.values
.filter { it.released }
.map {
SEpisode.create().apply {
@ -178,7 +178,7 @@ class Vizer : ConfigurableAnimeSource, AnimeHttpSource() {
override fun episodeListParse(response: Response): List<SEpisode> {
val doc = response.asJsoup()
val seasons = doc.select("div#seasonsList div.item[data-season-id]")
val seasons = doc.select("div.seasons div.list div.item[data-season-id]")
return if (seasons.size > 0) {
seasons.flatMap(::getSeasonEps).reversed()
} else {
@ -201,17 +201,24 @@ class Vizer : ConfigurableAnimeSource, AnimeHttpSource() {
} else {
// Fake url, its an ID that will be used to get episode languages
// (sub/dub) and then return the video link
apiRequest("getEpisodeLanguages=$url")
apiRequest("getEpisodeData=$url")
}
}
override fun videoListParse(response: Response): List<Video> {
val body = response.body.string()
val videoObjectList = if (body.startsWith("{")) {
json.decodeFromString<VideoLanguagesDto>(body).videos
body.parseAs<VideoListDto>().videos.values.toList()
} else {
val videoJson = body.substringAfterLast("videoPlayerBox(").substringBefore(");")
json.decodeFromString<VideoLanguagesDto>(videoJson).videos
val doc = response.asJsoup(body)
doc.select("div.audios div[data-load-player]").mapNotNull {
try {
val movieHosters = it.attr("data-players").parseAs<HostersDto>()
val movieId = it.attr("data-load-player")
val movieLang = if (it.hasClass("legendado")) "1" else "0"
VideoDto(movieId, movieLang).apply { hosters = movieHosters }
} catch (_: Throwable) { null }
}
}
return videoObjectList.flatMap(::getVideosFromObject)
@ -219,22 +226,23 @@ class Vizer : ConfigurableAnimeSource, AnimeHttpSource() {
private val mixdropExtractor by lazy { MixDropExtractor(client) }
private val streamtapeExtractor by lazy { StreamTapeExtractor(client) }
private val warezExtractor by lazy { WarezExtractor(client, headers) }
private fun getVideosFromObject(videoObj: VideoDto): List<Video> {
val players = client.newCall(apiRequest("getVideoPlayers=${videoObj.id}"))
.execute()
.parseAs<PlayersDto>()
val hosters = videoObj.hosters ?: return emptyList()
val langPrefix = if (videoObj.lang == "1") "LEG" else "DUB"
val videoList = players.iterator().mapNotNull { (name, status) ->
if (status == "0") return@mapNotNull null
return hosters.iterator().flatMap { (name, status) ->
if (status != 3) return@flatMap emptyList()
val url = getPlayerUrl(videoObj.id, name)
when (name) {
"mixdrop" -> mixdropExtractor.videoFromUrl(url, langPrefix)
"mixdrop" -> mixdropExtractor.videosFromUrl(url, langPrefix)
"streamtape" -> streamtapeExtractor.videosFromUrl(url, "StreamTape($langPrefix)")
else -> null
"warezcdn" -> warezExtractor.videosFromUrl(url, langPrefix)
else -> emptyList()
}
}.flatten()
return videoList
}
}
// ============================== Settings ==============================
@ -289,10 +297,19 @@ class Vizer : ConfigurableAnimeSource, AnimeHttpSource() {
}
// ============================= Utilities ==============================
private val noRedirectClient = client.newBuilder().followRedirects(false).build()
private fun getPlayerUrl(id: String, name: String): String {
val req = GET("$baseUrl/embed/getPlay.php?id=$id&sv=$name")
val body = client.newCall(req).execute().body.string()
return body.substringAfter("location.href=\"").substringBefore("\";")
val req = GET("$baseUrl/embed/getPlay.php?id=$id&sv=$name", headers)
return if (name == "warezcdn") {
val res = noRedirectClient.newCall(req).execute()
res.close()
res.headers["location"]!!
} else {
val res = client.newCall(req).execute()
val body = res.body.string()
body.substringAfter("location.href=\"", "").substringBefore("\";", "")
}
}
private fun apiRequest(body: String): Request {
@ -333,6 +350,7 @@ class Vizer : ConfigurableAnimeSource, AnimeHttpSource() {
private val PREF_PLAYER_ARRAY = arrayOf(
"MixDrop",
"StreamTape",
"WarezCDN",
)
private const val PREF_LANGUAGE_KEY = "pref_language"

60
src/pt/vizer/src/eu/kanade/tachiyomi/animeextension/pt/vizer/dto/VizerDto.kt
View File

@ -1,25 +1,22 @@
package eu.kanade.tachiyomi.animeextension.pt.vizer.dto
import eu.kanade.tachiyomi.util.parseAs
import kotlinx.serialization.EncodeDefault
import kotlinx.serialization.KSerializer
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
import kotlinx.serialization.builtins.ListSerializer
import kotlinx.serialization.json.JsonArray
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonTransformingSerializer
typealias FakeList<T> = Map<String, T>
@Serializable
data class SearchResultDto(
class SearchResultDto(
val quantity: Int = 0,
@Serializable(with = GenericListSerializer::class)
@EncodeDefault
val list: List<SearchItemDto> = emptyList(),
@SerialName("list")
val items: FakeList<SearchItemDto> = emptyMap(),
)
@Serializable
data class SearchItemDto(
class SearchItemDto(
val id: String,
val title: String,
val url: String,
@ -28,14 +25,13 @@ data class SearchItemDto(
)
@Serializable
data class EpisodeListDto(
@Serializable(with = GenericListSerializer::class)
class EpisodeListDto(
@SerialName("list")
val episodes: List<EpisodeItemDto>,
val episodes: FakeList<EpisodeItemDto>,
)
@Serializable
data class EpisodeItemDto(
class EpisodeItemDto(
val id: String,
val name: String,
val released: Boolean,
@ -43,36 +39,36 @@ data class EpisodeItemDto(
)
@Serializable
data class VideoLanguagesDto(
class VideoListDto(
@SerialName("list")
@Serializable(with = GenericListSerializer::class)
val videos: List<VideoDto>,
val videos: FakeList<VideoDto>,
)
@Serializable
data class VideoDto(
class VideoDto(
val id: String,
val lang: String,
)
@SerialName("players")
private val players: String? = null,
) {
var hosters = try {
players?.parseAs<HostersDto>()
} catch (e: Throwable) {
null
}
}
@Serializable
data class PlayersDto(
val mixdrop: String = "0",
val streamtape: String = "0",
class HostersDto(
val mixdrop: Int = 0,
val streamtape: Int = 0,
val warezcdn: Int = 0,
) {
operator fun iterator(): List<Pair<String, String>> {
operator fun iterator(): List<Pair<String, Int>> {
return listOf(
"mixdrop" to mixdrop,
"streamtape" to streamtape,
"warezcdn" to warezcdn,
)
}
}
class GenericListSerializer<T>(
private val itemSerializer: KSerializer<T>,
) : JsonTransformingSerializer<List<T>>(ListSerializer(itemSerializer)) {
override fun transformDeserialize(element: JsonElement): JsonElement {
val jsonObj = element as JsonObject
return JsonArray(jsonObj.values.toList())
}
}

52
src/pt/vizer/src/eu/kanade/tachiyomi/animeextension/pt/vizer/extractors/WarezExtractor.kt Normal file
View File

@ -0,0 +1,52 @@
package eu.kanade.tachiyomi.animeextension.pt.vizer.extractors
import android.util.Base64
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.FormBody
import okhttp3.Headers
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
class WarezExtractor(private val client: OkHttpClient, private val headers: Headers) {
fun videosFromUrl(url: String, lang: String): List<Video> {
val doc = client.newCall(GET(url, headers)).execute().asJsoup()
val httpUrl = doc.location().toHttpUrl()
val videoId = httpUrl.queryParameter("id") ?: return emptyList()
val script = doc.selectFirst("script:containsData(allowanceKey)")?.data()
?: return emptyList()
val key = script.substringAfter("allowanceKey").substringAfter('"').substringBefore('"')
val cdn = script.substringAfter("cdnListing").substringAfter('[').substringBefore(']')
.split(',')
.random()
val body = FormBody.Builder()
.add("getVideo", videoId)
.add("key", key)
.build()
val host = "https://" + httpUrl.host
val reqHeaders = headers.newBuilder()
.set("Origin", host)
.set("Referer", url)
.set("X-Requested-With", "XMLHttpRequest")
.build()
val req = client.newCall(POST("$host/player/functions.php", reqHeaders, body)).execute()
val id = req.body.string().substringAfter("id\":\"", "").substringBefore('"', "")
.ifBlank { return emptyList() }
val decrypted = decryptorium(id)
val videoUrl = "https://workerproxy.warezcdn.workers.dev/?url=https://cloclo$cdn.cloud.mail.ru/weblink/view/$decrypted"
return listOf(Video(videoUrl, "WarezCDN - $lang", videoUrl, headers))
}
private fun decryptorium(enc: String): String {
val b64dec = String(Base64.decode(enc, Base64.DEFAULT)).trim()
val start = b64dec.reversed().dropLast(5)
val end = b64dec.substring(0, 5)
return start + end
}
}