hentai moon

src/api.rs

@@ -648,42 +648,38 @@ async fn status(req: HttpRequest) -> Result<impl web::Responder, web::Error> {
         nsfw: true,
     });
 
-    // status.add_channel(Channel {
+    status.add_channel(Channel {
-    //     id: "hentaihaven".to_string(),
+        id: "hentaimoon".to_string(),
-    //     name: "Hentaihaven".to_string(),
+        name: "Hentai Moon".to_string(),
-    //     description: "(Work in Progress) Watch free hentai video stream in English subtitles".to_string(),
+        description: "Your Hentai Sputnik".to_string(),
-    //     premium: false,
+        premium: false,
-    //     favicon: "https://www.google.com/s2/favicons?sz=64&domain=hentaihaven.xxx".to_string(),
+        favicon: "https://www.google.com/s2/favicons?sz=64&domain=hentai-moon.com".to_string(),
-    //     status: "active".to_string(),
+        status: "active".to_string(),
-    //     categories: vec![],
+        categories: vec![],
-    //     options: vec![ChannelOption {
+        options: vec![ChannelOption {
-    //         id: "sort".to_string(),
+            id: "sort".to_string(),
-    //         title: "Sort".to_string(),
+            title: "Sort".to_string(),
-    //         description: "Sort the Videos".to_string(), //"Sort the videos by Date or Name.".to_string(),
+            description: "Sort the Videos".to_string(), //"Sort the videos by Date or Name.".to_string(),
-    //         systemImage: "list.number".to_string(),
+            systemImage: "list.number".to_string(),
-    //         colorName: "blue".to_string(),
+            colorName: "blue".to_string(),
-    //         options: vec![
+            options: vec![
-    //             FilterOption {
+                FilterOption {
-    //                 id: "new-manga".to_string(),
+                    id: "new".to_string(),
-    //                 title: "New".to_string(),
+                    title: "New".to_string(),
-    //             },
+                },
-    //             FilterOption {
+                FilterOption {
-    //                 id: "alphabet".to_string(),
+                    id: "popular".to_string(),
-    //                 title: "A-Z".to_string(),
+                    title: "Popular".to_string(),
-    //             },
+                },
-    //             FilterOption {
+                FilterOption {
-    //                 id: "rating".to_string(),
+                    id: "top-rated".to_string(),
-    //                 title: "Rating".to_string(),
+                    title: "Top Rated".to_string(),
-    //             },
+                },
-    //             FilterOption {
+            ],
-    //                 id: "views".to_string(),
+            multiSelect: false,
-    //                 title: "Most Views".to_string(),
+        }],
-    //             },
+        nsfw: true,
-    //         ],
+    });
-    //         multiSelect: false,
-    //     }],
-    //     nsfw: true,
-    // });
 
     status.iconUrl = format!("http://{}/favicon.ico", host).to_string();
     Ok(web::HttpResponse::Ok().json(&status))
@@ -806,6 +802,7 @@ pub fn get_provider(channel: &str) -> Option<AnyProvider> {
         "perfectgirls" => Some(AnyProvider::Perfectgirls(crate::providers::perfectgirls::PerfectgirlsProvider::new())),
         "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())),
         _ => Some(AnyProvider::Perverzija(PerverzijaProvider::new())),
     }
 }

src/providers/hentaimoon.rs

@@ -0,0 +1,284 @@
+use crate::schema::videos::url;
+use crate::util::parse_abbreviated_number;
+use crate::DbPool;
+use crate::providers::Provider;
+use crate::util::cache::VideoCache;
+use crate::util::flaresolverr::{FlareSolverrRequest, Flaresolverr};
+use crate::util::time::parse_time_to_seconds;
+use crate::videos::{ServerOptions, VideoItem};
+use error_chain::error_chain;
+use futures::stream::SplitSink;
+use htmlentity::entity::{ICodedDataTrait, decode};
+use std::env;
+use std::vec;
+use wreq::{Client, Proxy};
+use wreq_util::Emulation;
+
+error_chain! {
+    foreign_links {
+        Io(std::io::Error);
+        HttpRequest(wreq::Error);
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct HentaimoonProvider {
+    url: String,
+}
+impl HentaimoonProvider {
+    pub fn new() -> Self {
+        HentaimoonProvider {
+            url: "https://hentai-moon.com".to_string(),
+        }
+    }
+    async fn get(
+        &self,
+        cache: VideoCache,
+        page: u8,
+        sort: &str,
+    ) -> Result<Vec<VideoItem>> {
+        let sort_string = match sort {
+            "popular" => "/most-popular",
+            "top-rated" => "/top-rated",
+            _ => "/latest-updates/",
+        };
+
+        let list_str = match sort {
+            "popular" => "list_videos_common_videos_list",
+            "top-rated" => "list_videos_common_videos_list",
+            _ => "list_videos_most_recent_videos",
+        };
+
+        let video_url = format!("{}{}?mode=async^&function=get_block^&block_id={}^&from={}", self.url, sort_string, list_str, page);
+        let old_items = match cache.get(&video_url) {
+            Some((time, items)) => {
+                if time.elapsed().unwrap_or_default().as_secs() < 60 * 5 {
+                    println!("Cache hit for URL: {}", video_url);
+                    return Ok(items.clone());
+                } else {
+                    items.clone()
+                }
+            }
+            None => {
+                vec![]
+            }
+        };
+
+        let proxy = Proxy::all("http://192.168.0.103:8081").unwrap();
+        let client = Client::builder().cert_verification(false).emulation(Emulation::Firefox136).build()?;
+
+        let mut response = client.get(video_url.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());
+            if !video_items.is_empty() {
+                cache.remove(&video_url);
+                cache.insert(video_url.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: video_url.clone(),
+                    maxTimeout: 60000,
+                })
+                .await;
+            let video_items = match result {
+                Ok(res) => {
+                    // println!("FlareSolverr response: {}", res);
+                    self.get_video_items_from_html(res.solution.response)
+                }
+                Err(e) => {
+                    println!("Error solving FlareSolverr: {}", e);
+                    return Err("Failed to solve FlareSolverr".into());
+                }
+            };
+            if !video_items.is_empty() {
+                cache.remove(&video_url);
+                cache.insert(video_url.clone(), video_items.clone());
+            } else {
+                return Ok(old_items);
+            }
+            Ok(video_items)
+        }
+    }
+    async fn query(
+        &self,
+        cache: VideoCache,
+        page: u8,
+        query: &str,
+    ) -> Result<Vec<VideoItem>> {
+        let search_string = query.to_lowercase().trim().replace(" ", "-");
+        let mut video_url = format!("{}/search/{}/?mode=async&function=get_block&block_id=list_videos_videos_list_search_result&q=a&category_ids=&sort_by=&from_videos={}&from_albums={}&", self.url, search_string, page, page);
+        // Check our Video Cache. If the result is younger than 1 hour, we return it.
+        let old_items = match cache.get(&video_url) {
+            Some((time, items)) => {
+                if time.elapsed().unwrap_or_default().as_secs() < 60 * 5 {
+                    return Ok(items.clone());
+                } else {
+                    let _ = cache.check().await;
+                    return Ok(items.clone());
+                }
+            }
+            None => {
+                vec![]
+            }
+        };
+
+        let proxy = Proxy::all("http://192.168.0.103:8081").unwrap();
+        let client = Client::builder().cert_verification(false).emulation(Emulation::Firefox136).build()?;
+
+        let mut response = client.get(video_url.clone())
+        .proxy(proxy.clone())
+        .send().await?;
+
+        if response.status().is_redirection(){
+            
+            response = client.get(self.url.clone() + 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());
+            if !video_items.is_empty() {
+                cache.remove(&video_url);
+                cache.insert(video_url.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: video_url.clone(),
+                    maxTimeout: 60000,
+                })
+                .await;
+            let video_items = match result {
+                Ok(res) => self.get_video_items_from_html(res.solution.response),
+                Err(e) => {
+                    println!("Error solving FlareSolverr: {}", e);
+                    return Err("Failed to solve FlareSolverr".into());
+                }
+            };
+            if !video_items.is_empty() {
+                cache.remove(&video_url);
+                cache.insert(video_url.clone(), video_items.clone());
+            } else {
+                return Ok(old_items);
+            }
+            Ok(video_items)
+        }
+    }
+
+    fn get_video_items_from_html(&self, html: String) -> Vec<VideoItem> {
+        if html.is_empty() {
+            println!("HTML is empty");
+            return vec![];
+        }
+        let mut items: Vec<VideoItem> = Vec::new();
+        let raw_videos = html.split("<div class=\"pagination\"").collect::<Vec<&str>>()[0]
+            .split("<div class=\"item  \">")
+            .collect::<Vec<&str>>()[1..]
+            .to_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);
+            }
+            let video_url: String = format!("{}{}", self.url, video_segment.split("<a href=\"").collect::<Vec<&str>>()[1]
+                    .split("\"")
+                    .collect::<Vec<&str>>()[0]);
+            let mut title = video_segment.split("\" title=\"").collect::<Vec<&str>>()[1]
+                .split("\"")
+                .collect::<Vec<&str>>()[0]
+                .to_string();
+            // html decode
+            title = decode(title.as_bytes()).to_string().unwrap_or(title);
+            let id = video_url.split("/").collect::<Vec<&str>>()[4].to_string();
+            let raw_duration = video_segment.split("<div class=\"duration\">").collect::<Vec<&str>>()[1]
+                .split("<")
+                .collect::<Vec<&str>>()[0]
+                .to_string();
+            let duration = parse_time_to_seconds(&raw_duration).unwrap_or(0) as u32;
+
+            let thumb = video_segment.split("<img class=\"thumb ").collect::<Vec<&str>>()[1]
+                .split("data-original=\"").collect::<Vec<&str>>()[1]
+                .split("\"")
+                .collect::<Vec<&str>>()[0]
+                .to_string();
+
+            let views_part = video_segment.split("<div class=\"views\">").collect::<Vec<&str>>()[1]
+                .split("<")
+                .collect::<Vec<&str>>()[0]
+                .to_string();
+            let views = parse_abbreviated_number(&views_part).unwrap_or(0) as u32;
+
+            let video_item = VideoItem::new(
+                id,
+                title,
+                video_url.to_string(),
+                "hentaimoon".to_string(),
+                thumb,
+                duration,
+            )
+            .views(views)
+            ;
+            items.push(video_item);
+        }
+        return items;
+    }
+
+
+}
+
+impl Provider for HentaimoonProvider {
+    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 _ = pool;
+        let videos: std::result::Result<Vec<VideoItem>, Error> = match query {
+            Some(q) => {
+                self.query(cache, page.parse::<u8>().unwrap_or(1), &q,)
+                    .await
+            }
+            None => {
+                self.get(cache, page.parse::<u8>().unwrap_or(1), &sort)
+                    .await
+            }
+        };
+        match videos {
+            Ok(v) => v,
+            Err(e) => {
+                println!("Error fetching videos: {}", e);
+                vec![]
+            }
+        }
+    }
+}

src/providers/mod.rs

@@ -17,6 +17,7 @@ pub mod pornhat;
 pub mod perfectgirls;
 pub mod okxxx;
 pub mod homoxxx;
+pub mod hentaimoon;
 
 pub trait Provider {
     async fn get_videos(
@@ -46,6 +47,7 @@ pub enum AnyProvider {
     Perfectgirls(crate::providers::perfectgirls::PerfectgirlsProvider),
     Okxxx(crate::providers::okxxx::OkxxxProvider),
     Homoxxx(crate::providers::homoxxx::HomoxxxProvider),
+    Hentaimoon(crate::providers::hentaimoon::HentaimoonProvider),
 }
 
 impl Provider for AnyProvider {
@@ -124,6 +126,10 @@ impl Provider for AnyProvider {
                 p.get_videos(cache, pool, sort, query, page, per_page, options,)
                     .await
             }
+            AnyProvider::Hentaimoon(p) => {
+                p.get_videos(cache, pool, sort, query, page, per_page, options,)
+                    .await
+            }
         }
     }
 }