Samehadaku: added new sources

Samehadaku/build.gradle.kts

@@ -1,5 +1,5 @@
 // use an integer for version numbers
-version = 9
+version = 10
 
 
 cloudstream {

Samehadaku/src/main/kotlin/com/hexated/Extractors.kt

@@ -0,0 +1,43 @@
+package com.hexated
+
+import com.lagradost.cloudstream3.SubtitleFile
+import com.lagradost.cloudstream3.app
+import com.lagradost.cloudstream3.extractors.XStreamCdn
+import com.lagradost.cloudstream3.utils.ExtractorApi
+import com.lagradost.cloudstream3.utils.ExtractorLink
+import com.lagradost.cloudstream3.utils.Qualities
+import java.net.URI
+
+class Suzihaza: XStreamCdn() {
+    override val name: String = "Suzihaza"
+    override val mainUrl: String = "https://suzihaza.com"
+}
+
+open class Wibufile : ExtractorApi() {
+    override val name: String = "Wibufile"
+    override val mainUrl: String = "https://wibufile.com"
+    override val requiresReferer = false
+
+    override suspend fun getUrl(
+        url: String,
+        referer: String?,
+        subtitleCallback: (SubtitleFile) -> Unit,
+        callback: (ExtractorLink) -> Unit
+    ) {
+        val res = app.get(url).text
+        val video = Regex("src: ['\"](.*?)['\"]").find(res)?.groupValues?.get(1)
+
+        callback.invoke(
+            ExtractorLink(
+                name,
+                name,
+                video ?: return,
+                "$mainUrl/",
+                Qualities.Unknown.value,
+                URI(url).path.endsWith(".m3u8")
+            )
+        )
+
+    }
+
+}

Samehadaku/src/main/kotlin/com/hexated/Samehadaku.kt

@@ -2,13 +2,13 @@ package com.hexated
 
 import com.lagradost.cloudstream3.*
 import com.lagradost.cloudstream3.LoadResponse.Companion.addTrailer
-import com.lagradost.cloudstream3.extractors.XStreamCdn
 import com.lagradost.cloudstream3.utils.ExtractorLink
+import com.lagradost.cloudstream3.utils.Qualities
 import com.lagradost.cloudstream3.utils.loadExtractor
 import org.jsoup.nodes.Element
 
 class Samehadaku : MainAPI() {
-    override var mainUrl = "https://samehadaku.cam"
+    override var mainUrl = "https://samehadaku.day"
     override var name = "Samehadaku"
     override val hasMainPage = true
     override var lang = "id"
@@ -21,6 +21,8 @@ class Samehadaku : MainAPI() {
     )
 
     companion object {
+        const val acefile = "https://acefile.co"
+
         fun getType(t: String): TvType {
             return if (t.contains("OVA", true) || t.contains("Special", true)) TvType.OVA
             else if (t.contains("Movie", true)) TvType.AnimeMovie
@@ -72,7 +74,8 @@ class Samehadaku : MainAPI() {
     }
 
     private fun Element.toSearchResult(): AnimeSearchResponse? {
-        val title = this.selectFirst("div.title, h2.entry-title a, div.lftinfo h2")?.text()?.trim() ?: return null
+        val title = this.selectFirst("div.title, h2.entry-title a, div.lftinfo h2")?.text()?.trim()
+            ?: return null
         val href = fixUrlNull(this.selectFirst("a")?.attr("href") ?: return null)
         val posterUrl = fixUrlNull(this.select("img").attr("src"))
         val epNum = this.selectFirst("div.dtla author")?.text()?.toIntOrNull()
@@ -104,15 +107,20 @@ class Samehadaku : MainAPI() {
         val year = document.selectFirst("div.spe > span:contains(Rilis)")?.ownText()?.let {
             Regex("\\d,\\s(\\d*)").find(it)?.groupValues?.getOrNull(1)?.toIntOrNull()
         }
-        val status = getStatus(document.selectFirst("div.spe > span:contains(Status)")?.ownText() ?: return null)
+        val status = getStatus(
-        val type = document.selectFirst("div.spe > span:contains(Type)")?.ownText()?.trim()?.lowercase() ?: "tv"
+            document.selectFirst("div.spe > span:contains(Status)")?.ownText() ?: return null
+        )
+        val type =
+            document.selectFirst("div.spe > span:contains(Type)")?.ownText()?.trim()?.lowercase()
+                ?: "tv"
         val rating = document.selectFirst("span.ratingValue")?.text()?.trim()?.toRatingInt()
         val description = document.select("div.desc p").text().trim()
         val trailer = document.selectFirst("div.trailer-anime iframe")?.attr("src")
 
         val episodes = document.select("div.lstepsiode.listeps ul li").mapNotNull {
             val header = it.selectFirst("span.lchx > a") ?: return@mapNotNull null
-            val episode = Regex("Episode\\s?(\\d+)").find(header.text())?.groupValues?.getOrNull(1)?.toIntOrNull()
+            val episode = Regex("Episode\\s?(\\d+)").find(header.text())?.groupValues?.getOrNull(1)
+                ?.toIntOrNull()
             val link = fixUrl(header.attr("href"))
             Episode(link, episode = episode)
         }.reversed()
@@ -144,41 +152,83 @@ class Samehadaku : MainAPI() {
     ): Boolean {
 
         val document = app.get(data).document
-        val sources = ArrayList<String>()
 
-        document.select("div#server ul li div").apmap {
+        argamap(
-            val dataPost = it.attr("data-post")
+            {
-            val dataNume = it.attr("data-nume")
+                document.select("div#server ul li div").apmap {
-            val dataType = it.attr("data-type")
+                    val dataPost = it.attr("data-post")
+                    val dataNume = it.attr("data-nume")
+                    val dataType = it.attr("data-type")
 
-            val iframe = app.post(
+                    val iframe = app.post(
-                url = "$mainUrl/wp-admin/admin-ajax.php",
+                        url = "$mainUrl/wp-admin/admin-ajax.php",
-                data = mapOf(
+                        data = mapOf(
-                    "action" to "player_ajax",
+                            "action" to "player_ajax",
-                    "post" to dataPost,
+                            "post" to dataPost,
-                    "nume" to dataNume,
+                            "nume" to dataNume,
-                    "type" to dataType
+                            "type" to dataType
-                ),
+                        ),
-                referer = data,
+                        referer = data,
-                headers = mapOf("X-Requested-With" to "XMLHttpRequest")
+                        headers = mapOf("X-Requested-With" to "XMLHttpRequest")
-            ).document.select("iframe").attr("src")
+                    ).document.select("iframe").attr("src")
 
-            sources.add(fixUrl(iframe))
+                    loadFixedExtractor(fixedIframe(iframe), it.text(), "$mainUrl/", subtitleCallback, callback)
-        }
+
+                }
+            },
+            {
+                document.select("div#downloadb li").map { el ->
+                    el.select("a").apmap {
+                        loadFixedExtractor(fixedIframe(it.attr("href")), el.select("strong").text(), "$mainUrl/", subtitleCallback, callback)
+                    }
+                }
+            }
+        )
 
-        sources.apmap {
-            loadExtractor(it, "$mainUrl/", subtitleCallback, callback)
-        }
         return true
     }
 
-    private fun String.removeBloat() : String{
+    private suspend fun loadFixedExtractor(
+        url: String,
+        name: String,
+        referer: String? = null,
+        subtitleCallback: (SubtitleFile) -> Unit,
+        callback: (ExtractorLink) -> Unit
+    ) {
+        loadExtractor(url, referer, subtitleCallback) { link ->
+            callback.invoke(
+                ExtractorLink(
+                    link.name,
+                    link.name,
+                    link.url,
+                    link.referer,
+                    name.fixQuality(),
+                    link.isM3u8,
+                    link.headers,
+                    link.extractorData
+                )
+            )
+        }
+    }
+
+    private fun String.fixQuality() : Int {
+        return when(this) {
+            "MP4HD" -> Qualities.P720.value
+            "FULLHD" -> Qualities.P1080.value
+            else -> this.filter { it.isDigit() }.toIntOrNull() ?: Qualities.Unknown.value
+        }
+    }
+
+    private fun fixedIframe(url: String): String {
+        val id = Regex("""(?:/f/|/file/)(\w+)""").find(url)?.groupValues?.getOrNull(1)
+        return when {
+            url.startsWith(acefile) -> "${acefile}/player/$id"
+            else -> fixUrl(url)
+        }
+    }
+
+    private fun String.removeBloat(): String {
         return this.replace(Regex("(Nonton)|(Anime)|(Subtitle\\sIndonesia)"), "").trim()
     }
 
-}
+}
-
-class Suzihaza: XStreamCdn() {
-    override val name: String = "Suzihaza"
-    override val mainUrl: String = "https://suzihaza.com"
-}

Samehadaku/src/main/kotlin/com/hexated/SamehadakuPlugin.kt

@@ -11,5 +11,6 @@ class SamehadakuPlugin: Plugin() {
         // All providers should be added in this manner. Please don't edit the providers list directly.
         registerMainAPI(Samehadaku())
         registerExtractorAPI(Suzihaza())
+        registerExtractorAPI(Wibufile())
     }
 }