Ported over all movie providers (some disabled)

AllMoviesForYouProvider/build.gradle.kts

@@ -0,0 +1,22 @@
+// use an integer for version numbers
+version = 1
+
+
+cloudstream {
+    // All of these properties are optional, you can safely remove them
+
+    // description = "Lorem Ipsum"
+    // authors = listOf("Cloudburst")
+
+    /**
+    * Status int as the following:
+    * 0: Down
+    * 1: Ok
+    * 2: Slow
+    * 3: Beta only
+    * */
+    status = 1 // will be 3 if unspecified
+
+    // Set to true to get an 18+ symbol next to the plugin
+    adult = false // will be false if unspecified
+}

AllMoviesForYouProvider/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="com.lagradost"/>

AllMoviesForYouProvider/src/main/kotlin/com/lagradost/AllMoviesForYouProvider.kt

@@ -0,0 +1,206 @@
+package com.lagradost
+
+import com.lagradost.cloudstream3.*
+import com.lagradost.cloudstream3.LoadResponse.Companion.addDuration
+import com.lagradost.cloudstream3.mvvm.logError
+import com.lagradost.cloudstream3.utils.ExtractorLink
+import com.lagradost.cloudstream3.utils.loadExtractor
+import org.jsoup.Jsoup
+
+class AllMoviesForYouProvider : MainAPI() {
+    companion object {
+        fun getType(t: String): TvType {
+            return when {
+                t.contains("series") -> TvType.TvSeries
+                t.contains("movies") -> TvType.Movie
+                else -> TvType.Movie
+            }
+        }
+    }
+
+    // Fetching movies will not work if this link is outdated.
+    override var mainUrl = "https://allmoviesforyou.net"
+    override var name = "AllMoviesForYou"
+    override val hasMainPage = true
+    override val supportedTypes = setOf(
+        TvType.Movie,
+        TvType.TvSeries
+    )
+
+    override suspend fun getMainPage(page: Int, request : MainPageRequest): HomePageResponse {
+        val items = ArrayList<HomePageList>()
+        val soup = app.get(mainUrl).document
+        val urls = listOf(
+            Pair("Movies", "section[data-id=movies] article.TPost.B"),
+            Pair("TV Series", "section[data-id=series] article.TPost.B"),
+        )
+        for ((name, element) in urls) {
+            try {
+                val home = soup.select(element).map {
+                    val title = it.selectFirst("h2.title")!!.text()
+                    val link = it.selectFirst("a")!!.attr("href")
+                    TvSeriesSearchResponse(
+                        title,
+                        link,
+                        this.name,
+                        TvType.Movie,
+                        fixUrl(it.selectFirst("figure img")!!.attr("data-src")),
+                        null,
+                        null,
+                    )
+                }
+
+                items.add(HomePageList(name, home))
+            } catch (e: Exception) {
+                logError(e)
+            }
+        }
+        if (items.size <= 0) throw ErrorLoadingException()
+        return HomePageResponse(items)
+    }
+
+    override suspend fun search(query: String): List<SearchResponse> {
+        val url = "$mainUrl/?s=$query"
+        val document = app.get(url).document
+
+        val items = document.select("ul.MovieList > li > article > a")
+        return items.map { item ->
+            val href = item.attr("href")
+            val title = item.selectFirst("> h2.Title")!!.text()
+            val img = fixUrl(item.selectFirst("> div.Image > figure > img")!!.attr("data-src"))
+            val type = getType(href)
+            if (type == TvType.Movie) {
+                MovieSearchResponse(title, href, this.name, type, img, null)
+            } else {
+                TvSeriesSearchResponse(
+                    title,
+                    href,
+                    this.name,
+                    type,
+                    img,
+                    null,
+                    null
+                )
+            }
+        }
+    }
+
+//    private fun getLink(document: Document): List<String>? {
+//         val list = ArrayList<String>()
+//         Regex("iframe src=\"(.*?)\"").find(document.html())?.groupValues?.get(1)?.let {
+//             list.add(it)
+//         }
+//         document.select("div.OptionBx")?.forEach { element ->
+//             val baseElement = element.selectFirst("> a.Button")
+//             val elementText = element.selectFirst("> p.AAIco-dns")?.text()
+//             if (elementText == "Streamhub" || elementText == "Dood") {
+//                 baseElement?.attr("href")?.let { href ->
+//                     list.add(href)
+//                 }
+//             }
+//         }
+//
+//         return if (list.isEmpty()) null else list
+//     }
+
+    override suspend fun load(url: String): LoadResponse {
+        val type = getType(url)
+
+        val document = app.get(url).document
+
+        val title = document.selectFirst("h1.Title")!!.text()
+        val descipt = document.selectFirst("div.Description > p")!!.text()
+        val rating =
+            document.selectFirst("div.Vote > div.post-ratings > span")?.text()?.toRatingInt()
+        val year = document.selectFirst("span.Date")?.text()
+        val duration = document.selectFirst("span.Time")!!.text()
+        val backgroundPoster =
+            fixUrlNull(document.selectFirst("div.Image > figure > img")?.attr("data-src"))
+
+        if (type == TvType.TvSeries) {
+            val list = ArrayList<Pair<Int, String>>()
+
+            document.select("main > section.SeasonBx > div > div.Title > a").forEach { element ->
+                val season = element.selectFirst("> span")?.text()?.toIntOrNull()
+                val href = element.attr("href")
+                if (season != null && season > 0 && !href.isNullOrBlank()) {
+                    list.add(Pair(season, fixUrl(href)))
+                }
+            }
+            if (list.isEmpty()) throw ErrorLoadingException("No Seasons Found")
+
+            val episodeList = ArrayList<Episode>()
+
+            for (season in list) {
+                val seasonResponse = app.get(season.second).text
+                val seasonDocument = Jsoup.parse(seasonResponse)
+                val episodes = seasonDocument.select("table > tbody > tr")
+                if (episodes.isNotEmpty()) {
+                    episodes.forEach { episode ->
+                        val epNum = episode.selectFirst("> td > span.Num")?.text()?.toIntOrNull()
+                        val poster = episode.selectFirst("> td.MvTbImg > a > img")?.attr("data-src")
+                        val aName = episode.selectFirst("> td.MvTbTtl > a")
+                        val name = aName!!.text()
+                        val href = aName.attr("href")
+                        val date = episode.selectFirst("> td.MvTbTtl > span")?.text()
+
+                        episodeList.add(
+                            newEpisode(href) {
+                                this.name = name
+                                this.season = season.first
+                                this.episode = epNum
+                                this.posterUrl = fixUrlNull(poster)
+                                addDate(date)
+                            }
+                        )
+                    }
+                }
+            }
+            return TvSeriesLoadResponse(
+                title,
+                url,
+                this.name,
+                type,
+                episodeList,
+                backgroundPoster,
+                year?.toIntOrNull(),
+                descipt,
+                null,
+                rating
+            )
+        } else {
+            return newMovieLoadResponse(
+                title,
+                url,
+                type,
+                fixUrl(url)
+            ) {
+                posterUrl = backgroundPoster
+                this.year = year?.toIntOrNull()
+                this.plot = descipt
+                this.rating = rating
+                addDuration(duration)
+            }
+        }
+    }
+
+    override suspend fun loadLinks(
+        data: String,
+        isCasting: Boolean,
+        subtitleCallback: (SubtitleFile) -> Unit,
+        callback: (ExtractorLink) -> Unit
+    ): Boolean {
+        val doc = app.get(data).document
+        val iframe = doc.select("body iframe").map { fixUrl(it.attr("src")) }
+        iframe.apmap { id ->
+            if (id.contains("trembed")) {
+                val soup = app.get(id).document
+                soup.select("body iframe").map {
+                    val link = fixUrl(it.attr("src").replace("streamhub.to/d/", "streamhub.to/e/"))
+                    loadExtractor(link, data, subtitleCallback, callback)
+                }
+            } else loadExtractor(id, data, subtitleCallback, callback)
+        }
+        return true
+    }
+}

AllMoviesForYouProvider/src/main/kotlin/com/lagradost/AllMoviesForYouProviderPlugin.kt

@@ -0,0 +1,14 @@
+
+package com.lagradost
+
+import com.lagradost.cloudstream3.plugins.CloudstreamPlugin
+import com.lagradost.cloudstream3.plugins.Plugin
+import android.content.Context
+
+@CloudstreamPlugin
+class AllMoviesForYouProviderPlugin: Plugin() {
+    override fun load(context: Context) {
+        // All providers should be added in this manner. Please don't edit the providers list directly.
+        registerMainAPI(AllMoviesForYouProvider())
+    }
+}