Ported over all movie providers (some disabled)

MeloMovieProvider/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
+}

MeloMovieProvider/src/main/AndroidManifest.xml

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

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

@@ -0,0 +1,195 @@
+package com.lagradost
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.module.kotlin.readValue
+import com.lagradost.cloudstream3.*
+import com.lagradost.cloudstream3.LoadResponse.Companion.addImdbUrl
+import com.lagradost.cloudstream3.utils.AppUtils.parseJson
+import com.lagradost.cloudstream3.utils.ExtractorLink
+import com.lagradost.cloudstream3.utils.getQualityFromName
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Element
+
+class MeloMovieProvider : MainAPI() {
+    override var name = "MeloMovie"
+    override var mainUrl = "https://melomovie.com"
+    override val instantLinkLoading = true
+    override val hasQuickSearch = true
+    override val hasChromecastSupport = false // MKV FILES CANT BE PLAYED ON A CHROMECAST
+
+    data class MeloMovieSearchResult(
+        @JsonProperty("id") val id: Int,
+        @JsonProperty("imdb_code") val imdbId: String,
+        @JsonProperty("title") val title: String,
+        @JsonProperty("type") val type: Int, // 1 = MOVIE, 2 = TV-SERIES
+        @JsonProperty("year") val year: Int?, // 1 = MOVIE, 2 = TV-SERIES
+        //"mppa" for tags
+    )
+
+    data class MeloMovieLink(
+        @JsonProperty("name") val name: String,
+        @JsonProperty("link") val link: String
+    )
+
+    override suspend fun quickSearch(query: String): List<SearchResponse> {
+        return search(query)
+    }
+
+    override suspend fun search(query: String): List<SearchResponse> {
+        val url = "$mainUrl/movie/search/?name=$query"
+        val returnValue: ArrayList<SearchResponse> = ArrayList()
+        val response = app.get(url).text
+        val mapped = response.let { mapper.readValue<List<MeloMovieSearchResult>>(it) }
+        if (mapped.isEmpty()) return returnValue
+
+        for (i in mapped) {
+            val currentUrl = "$mainUrl/movie/${i.id}"
+            val currentPoster = "$mainUrl/assets/images/poster/${i.imdbId}.jpg"
+            if (i.type == 2) { // TV-SERIES
+                returnValue.add(
+                    TvSeriesSearchResponse(
+                        i.title,
+                        currentUrl,
+                        this.name,
+                        TvType.TvSeries,
+                        currentPoster,
+                        i.year,
+                        null
+                    )
+                )
+            } else if (i.type == 1) { // MOVIE
+                returnValue.add(
+                    MovieSearchResponse(
+                        i.title,
+                        currentUrl,
+                        this.name,
+                        TvType.Movie,
+                        currentUrl,
+                        i.year
+                    )
+                )
+            }
+        }
+        return returnValue
+    }
+
+    // http not https, the links are not https!
+    private fun fixUrl(url: String): String {
+        if (url.isEmpty()) return ""
+
+        if (url.startsWith("//")) {
+            return "http:$url"
+        }
+        if (!url.startsWith("http")) {
+            return "http://$url"
+        }
+        return url
+    }
+
+    private fun serializeData(element: Element): List<MeloMovieProvider.MeloMovieLink> {
+        val eps = element.select("> tbody > tr")
+        val parsed = eps.mapNotNull {
+            try {
+                val tds = it.select("> td")
+                val name = tds[if (tds.size == 5) 1 else 0].text()
+                val url = fixUrl(tds.last()!!.selectFirst("> a")!!.attr("data-lnk").replace(" ", "%20"))
+                MeloMovieLink(name, url)
+            } catch (e: Exception) {
+                MeloMovieLink("", "")
+            }
+        }.filter { it.link != "" && it.name != "" }
+        return parsed
+    }
+
+    override suspend fun loadLinks(
+        data: String,
+        isCasting: Boolean,
+        subtitleCallback: (SubtitleFile) -> Unit,
+        callback: (ExtractorLink) -> Unit
+    ): Boolean {
+        val links = parseJson<List<MeloMovieLink>>(data)
+        for (link in links) {
+            callback.invoke(
+                ExtractorLink(
+                    this.name,
+                    link.name,
+                    link.link,
+                    "",
+                    getQualityFromName(link.name),
+                    false
+                )
+            )
+        }
+        return true
+    }
+
+    override suspend fun load(url: String): LoadResponse? {
+        val response = app.get(url).text
+
+        //backdrop = imgurl
+        fun findUsingRegex(src: String): String? {
+            return src.toRegex().find(response)?.groups?.get(1)?.value ?: return null
+        }
+
+        val imdbUrl = findUsingRegex("var imdb = \"(.*?)\"")
+        val document = Jsoup.parse(response)
+        val poster = document.selectFirst("img.img-fluid")!!.attr("src")
+        val type = findUsingRegex("var posttype = ([0-9]*)")?.toInt() ?: return null
+        val titleInfo = document.selectFirst("div.movie_detail_title > div > div > h1")
+        val title = titleInfo!!.ownText()
+        val year =
+            titleInfo.selectFirst("> a")?.text()?.replace("(", "")?.replace(")", "")?.toIntOrNull()
+        val plot = document.selectFirst("div.col-lg-12 > p")!!.text()
+
+        if (type == 1) { // MOVIE
+            val serialize = document.selectFirst("table.accordion__list")
+                ?: throw ErrorLoadingException("No links found")
+            return newMovieLoadResponse(
+                title,
+                url,
+                TvType.Movie,
+                serializeData(serialize)
+            ) {
+                this.posterUrl = poster
+                this.year = year
+                this.plot = plot
+                addImdbUrl(imdbUrl)
+            }
+        } else if (type == 2) {
+            val episodes = ArrayList<Episode>()
+            val seasons = document.select("div.accordion__card")
+                ?: throw ErrorLoadingException("No episodes found")
+            for (s in seasons) {
+                val season =
+                    s.selectFirst("> div.card-header > button > span")!!.text()
+                        .replace("Season: ", "").toIntOrNull()
+                val localEpisodes = s.select("> div.collapse > div > div > div.accordion__card")
+                for (e in localEpisodes) {
+                    val episode =
+                        e.selectFirst("> div.card-header > button > span")!!.text()
+                            .replace("Episode: ", "").toIntOrNull()
+                    val links =
+                        e.selectFirst("> div.collapse > div > table.accordion__list") ?: continue
+                    val data = serializeData(links)
+                    episodes.add(newEpisode(data) {
+                        this.season = season
+                        this.episode = episode
+                    })
+                }
+            }
+            episodes.reverse()
+            return newTvSeriesLoadResponse(
+                title,
+                url,
+                TvType.TvSeries,
+                episodes
+            ) {
+                this.posterUrl = poster
+                this.year = year
+                this.plot = plot
+                addImdbUrl(imdbUrl)
+            }
+        }
+        return null
+    }
+}

MeloMovieProvider/src/main/kotlin/com/lagradost/MeloMovieProviderPlugin.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 MeloMovieProviderPlugin: Plugin() {
+    override fun load(context: Context) {
+        // All providers should be added in this manner. Please don't edit the providers list directly.
+        registerMainAPI(MeloMovieProvider())
+    }
+}