missav

src/api.rs

@@ -16,7 +16,7 @@ use crate::providers::redtube::RedtubeProvider;
 use crate::providers::rule34video::Rule34videoProvider;
 use crate::providers::spankbang::SpankbangProvider;
 use crate::util::cache::VideoCache;
-use crate::{DbPool, providers::*, status::*, videos::*};
+use crate::{db, providers::*, status::*, videos::*, DbPool};
 use cute::c;
 
 #[derive(Debug)]
@@ -690,6 +690,13 @@ async fn videos_post(
     cache: web::types::State<VideoCache>,
     pool: web::types::State<DbPool>,
 ) -> Result<impl web::Responder, web::Error> {
+
+    let mut conn = pool.get().expect("couldn't get db connection from pool");
+    // Ensure "videos" table exists with two string columns
+    if !(db::has_table(&mut conn, "videos").unwrap()){
+        db::create_table(&mut conn, "CREATE TABLE videos (id TEXT NOT NULL, url TEXT NOT NULL);");
+    }
+
     let mut videos = Videos {
         pageInfo: PageInfo {
             hasNextPage: true,
@@ -803,6 +810,7 @@ pub fn get_provider(channel: &str) -> Option<AnyProvider> {
         "okxxx" => Some(AnyProvider::Okxxx(crate::providers::okxxx::OkxxxProvider::new())),
         "homoxxx" => Some(AnyProvider::Homoxxx(crate::providers::homoxxx::HomoxxxProvider::new())),
         "hentaimoon" => Some(AnyProvider::Hentaimoon(crate::providers::hentaimoon::HentaimoonProvider::new())),
+        "missav" => Some(AnyProvider::Missav(crate::providers::missav::MissavProvider::new())),
         _ => Some(AnyProvider::Perverzija(PerverzijaProvider::new())),
     }
 }

src/db.rs

@@ -14,6 +14,7 @@ pub fn get_video(conn: &mut SqliteConnection, video_id: String) -> Result<Option
     }
 }
 
+
 pub fn insert_video(conn: &mut SqliteConnection, new_id: &str, new_url: &str) -> Result<usize, diesel::result::Error> {
     use crate::schema::videos::dsl::*;
     diesel::insert_into(videos).values(DBVideo{
@@ -27,3 +28,24 @@ pub fn delete_video(conn: &mut SqliteConnection, video_id: String) -> Result<usi
     diesel::delete(videos.filter(id.eq(video_id))).execute(conn)
 }
 
+pub fn has_table(conn: &mut SqliteConnection, table_name: &str) -> Result<bool, diesel::result::Error> {
+    use diesel::sql_query;
+    use diesel::sql_types::Text;
+    #[derive(QueryableByName)]
+    struct TableName {
+        #[sql_type = "Text"]
+        name: String,
+    }
+    let query = "SELECT name FROM sqlite_master WHERE type='table' AND name = ?1";
+    let result = sql_query(query)
+        .bind::<Text, _>(table_name)
+        .load::<TableName>(conn)?;
+    Ok(!result.is_empty())
+}
+
+pub fn create_table(conn: &mut SqliteConnection, create_sql: &str) -> Result<(), diesel::result::Error> {
+    use diesel::sql_query;
+    sql_query(create_sql).execute(conn)?;
+    Ok(())
+}
+

src/main.rs

@@ -37,13 +37,15 @@ async fn main() -> std::io::Result<()> {
 
     // set up database connection pool
     let connspec = std::env::var("DATABASE_URL").expect("DATABASE_URL");
-    let manager = ConnectionManager::<SqliteConnection>::new(connspec);
+    let manager = ConnectionManager::<SqliteConnection>::new(connspec.clone());
     let pool = r2d2::Pool::builder()
         .build(manager)
         .expect("Failed to create pool.");
 
+
     let cache: util::cache::VideoCache = crate::util::cache::VideoCache::new();
 
+    
     web::HttpServer::new(move || {
         web::App::new()
             .state(pool.clone())

src/providers/missav.rs

@@ -0,0 +1,375 @@
+use std::vec;
+use std::env;
+use error_chain::error_chain;
+use htmlentity::entity::{decode, ICodedDataTrait};
+use futures::future::join_all;
+use wreq::Client;
+use wreq::Proxy;
+use wreq_util::Emulation;
+use crate::db;
+use crate::providers::Provider;
+use crate::util::cache::VideoCache;
+use crate::util::flaresolverr::{FlareSolverrRequest, Flaresolverr};
+use crate::videos::ServerOptions;
+use crate::videos::{VideoItem};
+use crate::DbPool;
+
+
+error_chain! {
+    foreign_links {
+        Io(std::io::Error);
+        HttpRequest(wreq::Error);
+        JsonError(serde_json::Error);
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct MissavProvider {
+    url: String,
+}
+impl MissavProvider {
+    pub fn new() -> Self {
+        MissavProvider {
+            url: "https://missav.ws".to_string(),
+        }
+    }
+    async fn get(&self, cache:VideoCache, pool:DbPool, page: u8) -> Result<Vec<VideoItem>> {
+
+        let url_str = format!("{}/en/new?page={}", self.url, page);
+        
+        let old_items = match cache.get(&url_str) {
+            Some((time, items)) => {
+                if time.elapsed().unwrap_or_default().as_secs() < 60 * 60 {
+                    return Ok(items.clone());
+                }
+                else{
+                    items.clone()
+                }
+            }
+            None => {
+                vec![]
+            }
+        };
+
+        
+        let client = Client::builder().cert_verification(false).emulation(Emulation::Firefox136).build()?;
+
+        let proxy = Proxy::all("http://192.168.0.103:8081").unwrap();
+        
+        let mut response = client.get(url_str.clone())
+        .proxy(proxy.clone())
+        .send().await?;
+        if response.status().is_redirection(){
+            response = client.get(response.headers()["Location"].to_str().unwrap())
+            .proxy(proxy.clone())
+            .send().await?;
+        }
+        if response.status().is_success() {
+            let text = response.text().await?;
+            let video_items: Vec<VideoItem> = self.get_video_items_from_html(text.clone(), pool).await;
+            if !video_items.is_empty() {
+                cache.remove(&url_str);
+                cache.insert(url_str.clone(), video_items.clone());
+            } else{
+                return Ok(old_items);
+            }
+            Ok(video_items)
+        } else {
+            let flare_url = env::var("FLARE_URL").expect("FLARE_URL not set");
+            let flare = Flaresolverr::new(flare_url);
+            let result = flare
+                .solve(FlareSolverrRequest {
+                    cmd: "request.get".to_string(),
+                    url: url_str.clone(),
+                    maxTimeout: 60000,
+                })
+                .await;
+            let video_items = match result {
+                Ok(res) => {
+                    // println!("FlareSolverr response: {}", res);
+                    self.get_video_items_from_html(res.solution.response, pool).await
+                }
+                Err(e) => {
+                    println!("Error solving FlareSolverr: {}", e);
+                    return Err("Failed to solve FlareSolverr".into());
+                }
+            };
+            if !video_items.is_empty() {
+                cache.remove(&url_str);
+                cache.insert(url_str.clone(), video_items.clone());
+            } else {
+                return Ok(old_items);
+            }
+            Ok(video_items)
+        }
+    }
+    async fn query(&self, cache: VideoCache, pool:DbPool, page: u8, query: &str) -> Result<Vec<VideoItem>> {
+        let search_string = query.replace(" ", "%20");
+        let url_str = format!(
+            "{}/en/search/{}?page={}",
+            self.url, search_string, page
+        );
+        // Check our Video Cache. If the result is younger than 1 hour, we return it.
+        let old_items = match cache.get(&url_str) {
+            Some((time, items)) => {
+                if time.elapsed().unwrap_or_default().as_secs() < 60 * 60 {
+                    return Ok(items.clone());
+                }
+                else{
+                    let _ = cache.check().await;
+                    return Ok(items.clone())
+                }
+            }
+            None => {
+                vec![]
+            }
+        };    
+        let client = Client::builder().cert_verification(false).emulation(Emulation::Firefox136).build()?;
+
+        let proxy = Proxy::all("http://192.168.0.103:8081").unwrap();
+        
+        let mut response = client.get(url_str.clone())
+        .proxy(proxy.clone())
+        .send().await?;
+        if response.status().is_redirection(){
+            response = client.get(response.headers()["Location"].to_str().unwrap())
+            .proxy(proxy.clone())
+            .send().await?;
+        }
+        if response.status().is_success() {
+            let text = response.text().await?;
+            let video_items: Vec<VideoItem> = self.get_video_items_from_html(text.clone(), pool).await;
+            if !video_items.is_empty() {
+                cache.remove(&url_str);
+                cache.insert(url_str.clone(), video_items.clone());
+            } else{
+                return Ok(old_items);
+            }
+            Ok(video_items)
+        } else {
+            let flare_url = env::var("FLARE_URL").expect("FLARE_URL not set");
+            let flare = Flaresolverr::new(flare_url);
+            let result = flare
+                .solve(FlareSolverrRequest {
+                    cmd: "request.get".to_string(),
+                    url: url_str.clone(),
+                    maxTimeout: 60000,
+                })
+                .await;
+            let video_items = match result {
+                Ok(res) => {
+                    self.get_video_items_from_html(res.solution.response, pool).await
+                }
+                Err(e) => {
+                    println!("Error solving FlareSolverr: {}", e);
+                    return Err("Failed to solve FlareSolverr".into());
+                }
+            };
+            if !video_items.is_empty() {
+                cache.remove(&url_str);
+                cache.insert(url_str.clone(), video_items.clone());
+            } else{
+                return Ok(old_items);
+            }
+            Ok(video_items)
+        }
+    }
+
+    async fn get_video_items_from_html(&self, html: String, pool: DbPool) -> Vec<VideoItem> {
+        if html.is_empty() {
+            println!("HTML is empty");
+            return vec![];
+        }
+        let raw_videos = html
+            .split("@mouseenter=\"setPreview(\'")
+            .collect::<Vec<&str>>()[1..]
+            .to_vec();
+        let mut urls: Vec<String> = vec![];
+        for video_segment in &raw_videos {
+            // let vid = video_segment.split("\n").collect::<Vec<&str>>();
+            // for (index, line) in vid.iter().enumerate() {
+            //     println!("Line {}: {}", index, line.to_string().trim());
+            // }
+           
+            let url_str = video_segment.split("<a href=\"").collect::<Vec<&str>>()[1]
+                .split("\"")
+                .collect::<Vec<&str>>()[0]
+                .to_string();
+            urls.push(url_str.clone());
+            
+        }
+        let futures = urls.into_iter().map(|el| self.get_video_item(el.clone(), pool.clone()));
+        let results: Vec<Result<VideoItem>> = join_all(futures).await;
+        let video_items: Vec<VideoItem> = results
+            .into_iter()
+            .filter_map(Result::ok)
+            .collect();   
+
+        return video_items;
+    }
+
+    async fn get_video_item(&self, url_str: String, pool: DbPool) -> Result<VideoItem> {
+        let mut conn = pool.get().expect("couldn't get db connection from pool");
+        let db_result = db::get_video(&mut conn,url_str.clone());
+        match db_result {
+            Ok(Some(entry)) => {
+                let video_item: VideoItem = serde_json::from_str(entry.as_str()).unwrap();
+                return Ok(video_item)
+            }
+            Ok(None) => {
+            }
+            Err(e) => {
+                println!("Error fetching video from database: {}", e);
+            }
+        }
+        drop(conn);
+        
+
+        let client = Client::builder().cert_verification(false).emulation(Emulation::Firefox136).build()?;
+
+        let proxy = Proxy::all("http://192.168.0.103:8081").unwrap();
+        
+        let mut response = client.get(url_str.clone())
+        .proxy(proxy.clone())
+        .send().await?;
+        if response.status().is_redirection(){
+            response = client.get(response.headers()["Location"].to_str().unwrap())
+            .proxy(proxy.clone())
+            .send().await?;
+        }
+        let vid;
+        if response.status().is_success() {
+            vid = response.text().await?;
+        } else {
+            return Err("Failed to fetch video details".into());
+        }
+        let mut title = vid.split("<meta property=\"og:title\" content=\"").collect::<Vec<&str>>()[1]
+            .split("\"")
+            .collect::<Vec<&str>>()[0]
+            .to_string();
+        title = decode(title.as_bytes()).to_string().unwrap_or(title);
+
+        let thumb = vid.split("<meta property=\"og:image\" content=\"").collect::<Vec<&str>>()[1]
+            .split("\"")
+            .collect::<Vec<&str>>()[0]
+            .to_string();
+
+        let raw_duration = vid.split("<meta property=\"og:video:duration\" content=\"").collect::<Vec<&str>>()[1]
+            .split("\"")
+            .collect::<Vec<&str>>()[0]
+            .to_string();
+        let duration = raw_duration.parse::<u32>().unwrap_or(0);
+
+        let id = url_str.split("/").collect::<Vec<&str>>()[4]
+            .to_string();
+        let mut tags = vec![];
+        if vid.contains("<span>Actress:</span>"){
+            for actress_snippet in vid.split("<span>Actress:</span>").collect::<Vec<&str>>()[1]
+            .split("</div>").collect::<Vec<&str>>()[0].split("class=\"text-nord13 font-medium\">"){
+                let tag = actress_snippet.split("<").collect::<Vec<&str>>()[0].trim()
+                    .to_string();
+                if !tag.is_empty(){
+                    tags.push(format!("@genre:{}", tag));
+                }
+            }
+        }
+        if vid.contains("<span>Actor:</span>"){
+            for actor_snippet in vid.split("<span>Actor:</span>").collect::<Vec<&str>>()[1]
+            .split("</div>").collect::<Vec<&str>>()[0].split("class=\"text-nord13 font-medium\">"){
+                let tag = actor_snippet.split("<").collect::<Vec<&str>>()[0].trim()
+                    .to_string();
+                if !tag.is_empty(){
+                    tags.push(format!("@genre:{}", tag));
+                }
+            }
+        }
+        
+        if vid.contains("<span>Maker:</span>"){
+            for maker_snippet in vid.split("<span>Maker:</span>").collect::<Vec<&str>>()[1]
+            .split("</div>").collect::<Vec<&str>>()[0]
+            .split("class=\"text-nord13 font-medium\">"){
+                let tag = maker_snippet.split("<").collect::<Vec<&str>>()[0].trim()
+                    .to_string();
+                if !tag.is_empty(){
+                    tags.push(format!("@genre:{}", tag));
+                }
+            }
+        }
+
+        if vid.contains("<span>Genre:</span>"){
+            for tag_snippet in vid.split("<span>Genre:</span>").collect::<Vec<&str>>()[1]
+            .split("</div>").collect::<Vec<&str>>()[0].split("class=\"text-nord13 font-medium\">"){
+                let tag = tag_snippet.split("<").collect::<Vec<&str>>()[0].trim()
+                    .to_string();
+                if !tag.is_empty(){
+                    tags.push(format!("@genre:{}", tag));
+                }
+            }
+        }
+        
+        let preview = format!("https://fourhoi.com/{}/preview.mp4",id.clone());
+
+        let mut video_url_parts = vid.split("m3u8").collect::<Vec<&str>>()[1]
+            .split("https").collect::<Vec<&str>>()[0]
+            .split("|").collect::<Vec<&str>>();
+        video_url_parts.reverse();  
+        let video_url = format!("https://{}.{}/{}-{}-{}-{}-{}/playlist.m3u8", 
+                                        video_url_parts[1],
+                                        video_url_parts[2],
+                                        video_url_parts[3],
+                                        video_url_parts[4],
+                                        video_url_parts[5],
+                                        video_url_parts[6],
+                                        video_url_parts[7]
+                                    );
+        let mut video_item = VideoItem::new(
+            id,
+            title,
+            video_url.clone(),
+            "missav".to_string(),
+            thumb,
+            duration,
+        )
+        .tags(tags)
+        .preview(preview)
+        ;
+
+        let mut conn = pool.get().expect("couldn't get db connection from pool");
+        let insert_result = db::insert_video(&mut conn, &url_str, &serde_json::to_string(&video_item)?);
+        match insert_result{
+            Ok(_) => (),
+            Err(e) => {println!("{:?}", e); }
+        }
+        drop(conn);
+
+        return Ok(video_item);
+    }
+}
+
+impl Provider for MissavProvider {
+    async fn get_videos(
+        &self,
+        cache: VideoCache,
+        pool: DbPool,
+        sort: String,
+        query: Option<String>,
+        page: String,
+        per_page: String,
+        options: ServerOptions,
+    ) -> Vec<VideoItem> {
+        let _ = options;
+        let _ = per_page;
+        let _ = sort;
+        let videos: std::result::Result<Vec<VideoItem>, Error> = match query {
+            Some(q) => self.query(cache, pool, page.parse::<u8>().unwrap_or(1), &q).await,
+            None => self.get(cache, pool, page.parse::<u8>().unwrap_or(1)).await,
+        };
+        match videos {
+            Ok(v) => v,
+            Err(e) => {
+                println!("Error fetching videos: {}", e);
+                vec![]
+            }
+        }
+    }
+}

src/providers/mod.rs

@@ -18,6 +18,7 @@ pub mod perfectgirls;
 pub mod okxxx;
 pub mod homoxxx;
 pub mod hentaimoon;
+pub mod missav;
 
 pub trait Provider {
     async fn get_videos(
@@ -48,6 +49,7 @@ pub enum AnyProvider {
     Okxxx(crate::providers::okxxx::OkxxxProvider),
     Homoxxx(crate::providers::homoxxx::HomoxxxProvider),
     Hentaimoon(crate::providers::hentaimoon::HentaimoonProvider),
+    Missav(crate::providers::missav::MissavProvider),
 }
 
 impl Provider for AnyProvider {
@@ -130,6 +132,10 @@ impl Provider for AnyProvider {
                 p.get_videos(cache, pool, sort, query, page, per_page, options,)
                     .await
             }
+            AnyProvider::Missav(p) => {
+                p.get_videos(cache, pool, sort, query, page, per_page, options,)
+                    .await
+            }
         }
     }
 }

src/videos.rs

@@ -44,7 +44,7 @@ pub struct PageInfo {
 }
 
 
-#[derive(serde::Serialize, Debug, Clone)]
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
 pub struct VideoEmbed{
     pub html: String,
     pub source: String,
@@ -57,7 +57,7 @@ impl VideoEmbed {
         }
     }
 }
-#[derive(serde::Serialize, Debug, Clone)]
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
 pub struct VideoItem {
     pub duration: u32,              // 110,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -172,7 +172,7 @@ impl VideoItem {
     }
 }
 
-#[derive(serde::Serialize, Debug, Clone)]
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
 pub struct VideoFormat {
     url: String,
     quality: String,