cloudstream-extensions-hexated/RebahinProvider/src/main/kotlin/com/hexated/RebahinProvider.kt

325 lines
12 KiB
Kotlin
Raw Normal View History

2022-09-09 16:09:54 +00:00
package com.hexated
import com.fasterxml.jackson.annotation.JsonProperty
import com.lagradost.cloudstream3.*
import com.lagradost.cloudstream3.LoadResponse.Companion.addActors
import com.lagradost.cloudstream3.LoadResponse.Companion.addTrailer
import com.lagradost.cloudstream3.mvvm.logError
import com.lagradost.cloudstream3.mvvm.safeApiCall
import com.lagradost.cloudstream3.network.WebViewResolver
import com.lagradost.cloudstream3.utils.AppUtils.tryParseJson
import com.lagradost.cloudstream3.utils.ExtractorLink
import com.lagradost.cloudstream3.utils.getQualityFromName
import com.lagradost.cloudstream3.utils.loadExtractor
import org.jsoup.nodes.Element
import java.net.URI
class RebahinProvider : MainAPI() {
override var mainUrl = "http://104.237.198.194"
override var name = "Rebahin"
override val hasMainPage = true
override var lang = "id"
override val hasDownloadSupport = true
override val supportedTypes = setOf(
TvType.Movie,
TvType.TvSeries,
TvType.Anime,
TvType.AsianDrama
)
override suspend fun getMainPage(page: Int, request : MainPageRequest): HomePageResponse {
val urls = listOf(
Pair("Featured", "xtab1"),
Pair("Film Terbaru", "xtab2"),
Pair("Romance", "xtab3"),
Pair("Drama", "xtab4"),
Pair("Action", "xtab5"),
Pair("Scifi", "xtab6"),
Pair("Tv Series Terbaru", "stab1"),
Pair("Anime Series", "stab2"),
Pair("Drakor Series", "stab3"),
Pair("West Series", "stab4"),
Pair("China Series", "stab5"),
Pair("Japan Series", "stab6"),
)
val items = ArrayList<HomePageList>()
for ((header, tab) in urls) {
try {
val home =
app.get("$mainUrl/wp-content/themes/indoxxi/ajax-top-$tab.php").document.select(
"div.ml-item"
).map {
it.toSearchResult()
}
items.add(HomePageList(header, home))
} catch (e: Exception) {
logError(e)
}
}
if (items.size <= 0) throw ErrorLoadingException()
return HomePageResponse(items)
}
private fun Element.toSearchResult(): SearchResponse {
val title = this.selectFirst("span.mli-info > h2")!!.text().trim()
val href = this.selectFirst("a")!!.attr("href")
val type =
if (this.select("span.mli-quality").isNotEmpty()) TvType.Movie else TvType.TvSeries
return if (type == TvType.Movie) {
val posterUrl = this.select("img").attr("src")
val quality = getQualityFromString(this.select("span.mli-quality").text().trim())
newMovieSearchResponse(title, href, TvType.Movie) {
this.posterUrl = posterUrl
this.quality = quality
}
} else {
val posterUrl =
this.select("img").attr("src").ifEmpty { this.select("img").attr("data-original") }
val episode =
this.select("div.mli-eps > span").text().replace(Regex("[^0-9]"), "").toIntOrNull()
newAnimeSearchResponse(title, href, TvType.TvSeries) {
this.posterUrl = posterUrl
addSub(episode)
}
}
}
override suspend fun search(query: String): List<SearchResponse> {
val link = "$mainUrl/?s=$query"
val document = app.get(link).document
return document.select("div.ml-item").map {
it.toSearchResult()
}
}
override suspend fun load(url: String): LoadResponse {
val document = app.get(url).document
val title = document.selectFirst("h3[itemprop=name]")!!.ownText().trim()
val poster = document.select(".mvic-desc > div.thumb.mvic-thumb").attr("style")
.substringAfter("url(").substringBeforeLast(")")
val tags = document.select("span[itemprop=genre]").map { it.text() }
val year = Regex("([0-9]{4}?)-").find(
document.selectFirst(".mvici-right > p:nth-child(3)")!!.ownText().trim()
)?.groupValues?.get(1).toString().toIntOrNull()
val tvType = if (url.contains("/series/")) TvType.TvSeries else TvType.Movie
val description = document.select("span[itemprop=reviewBody] > p").text().trim()
val trailer = fixUrlNull(document.selectFirst("div.modal-body-trailer iframe")?.attr("src"))
val rating = document.selectFirst("span[itemprop=ratingValue]")?.text()?.toRatingInt()
val duration = document.selectFirst(".mvici-right > p:nth-child(1)")!!
.ownText().replace(Regex("[^0-9]"), "").toIntOrNull()
val actors = document.select("span[itemprop=actor] > a").map { it.select("span").text() }
val baseLink = fixUrl(document.select("div#mv-info > a").attr("href").toString())
return if (tvType == TvType.TvSeries) {
val episodes = app.get(baseLink).document.select("div#list-eps > a").map {
Pair(it.text(), it.attr("data-iframe"))
}.groupBy { it.first }.map { eps ->
Episode(
data = eps.value.map { fixUrl(base64Decode(it.second)) }.toString(),
name = eps.key,
episode = eps.key.filter { it.isDigit() }.toIntOrNull()
)
}
newTvSeriesLoadResponse(title, url, TvType.TvSeries, episodes) {
this.posterUrl = poster
this.year = year
this.plot = description
this.tags = tags
this.rating = rating
this.duration = duration
addActors(actors)
addTrailer(trailer)
}
} else {
val links =
app.get(baseLink).document.select("div#server-list div.server-wrapper div[id*=episode]")
.map {
fixUrl(base64Decode(it.attr("data-iframe")))
}.toString()
newMovieLoadResponse(title, url, TvType.Movie, links) {
this.posterUrl = poster
this.year = year
this.plot = description
this.tags = tags
this.rating = rating
this.duration = duration
addActors(actors)
addTrailer(trailer)
}
}
}
private suspend fun invokeLokalSource(
url: String,
name: String,
ref: String,
subCallback: (SubtitleFile) -> Unit,
sourceCallback: (ExtractorLink) -> Unit
) {
val document = app.get(
url,
allowRedirects = false,
referer = mainUrl,
headers = mapOf("Accept" to "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8")
).document
document.select("script").map { script ->
if (script.data().contains("sources: [")) {
val source = tryParseJson<ResponseLocal>(
script.data().substringAfter("sources: [").substringBefore("],")
)
val m3uData = app.get(source!!.file, referer = ref).text
val quality = Regex("\\d{3,4}\\.m3u8").findAll(m3uData).map { it.value }.toList()
quality.forEach {
sourceCallback.invoke(
ExtractorLink(
source = name,
name = name,
url = source.file.replace("video.m3u8", it),
referer = ref,
quality = getQualityFromName("${it.replace(".m3u8", "")}p"),
isM3u8 = true
)
)
}
val trackJson = script.data().substringAfter("tracks: [").substringBefore("],")
val track = tryParseJson<List<Tracks>>("[$trackJson]")
track?.map {
subCallback.invoke(
SubtitleFile(
"Indonesian",
(if (it.file.contains(".srt")) it.file else null)!!
)
)
}
}
}
}
private suspend fun invokeKotakAjairSource(
url: String,
subCallback: (SubtitleFile) -> Unit,
sourceCallback: (ExtractorLink) -> Unit
) {
val domainUrl = "https://kotakajair.xyz"
val id = url.trimEnd('/').split("/").last()
val sources = app.post(
url = "$domainUrl/api/source/$id",
data = mapOf("r" to mainUrl, "d" to URI(url).host)
).parsed<ResponseKotakAjair>()
sources.data?.map {
sourceCallback.invoke(
ExtractorLink(
name,
"KotakAjair",
fixUrl(it.file),
referer = url,
quality = getQualityFromName(it.label)
)
)
}
val userData = sources.player.poster_file.split("/")[2]
sources.captions?.map {
subCallback.invoke(
SubtitleFile(
if (it.language.lowercase().contains("eng")) it.language else "Indonesian",
"$domainUrl/asset/userdata/$userData/caption/${it.hash}/${it.id}.srt"
)
)
}
}
override suspend fun loadLinks(
data: String,
isCasting: Boolean,
subtitleCallback: (SubtitleFile) -> Unit,
callback: (ExtractorLink) -> Unit
): Boolean {
data.removeSurrounding("[", "]").split(",").map { it.trim() }.apmap { link ->
safeApiCall {
when {
link.startsWith("http://172.96.161.72") -> invokeLokalSource(
link,
this.name,
"http://172.96.161.72/",
subtitleCallback,
callback
)
link.startsWith("https://kotakajair.xyz") -> invokeKotakAjairSource(
link,
subtitleCallback,
callback
)
else -> {
loadExtractor(link, "$mainUrl/", subtitleCallback, callback)
if (link.startsWith("https://sbfull.com")) {
val response = app.get(
link, interceptor = WebViewResolver(
Regex("""\.srt""")
)
)
subtitleCallback.invoke(
SubtitleFile(
"Indonesian",
response.url
)
)
}
}
}
}
}
return true
}
private data class ResponseLocal(
@JsonProperty("file") val file: String,
@JsonProperty("label") val label: String,
@JsonProperty("type") val type: String?
)
private data class Tracks(
@JsonProperty("file") val file: String,
@JsonProperty("label") val label: String?,
@JsonProperty("kind") val kind: String?
)
private data class Captions(
@JsonProperty("id") val id: String,
@JsonProperty("hash") val hash: String,
@JsonProperty("language") val language: String,
)
private data class Data(
@JsonProperty("file") val file: String,
@JsonProperty("label") val label: String,
)
private data class Player(
@JsonProperty("poster_file") val poster_file: String,
)
private data class ResponseKotakAjair(
@JsonProperty("success") val success: Boolean,
@JsonProperty("player") val player: Player,
@JsonProperty("data") val data: List<Data>?,
@JsonProperty("captions") val captions: List<Captions>?
)
}