From aaff7d00c63f9d37c3b162ed76a544e476a987f5 Mon Sep 17 00:00:00 2001 From: Simon Date: Sat, 10 Jan 2026 18:29:29 +0000 Subject: [PATCH] hypnotube --- src/providers/hanime.rs | 2 +- src/providers/hypnotube.rs | 417 +++++++++++++++++++++++++++++++++++++ src/providers/mod.rs | 2 + src/util/requester.rs | 25 ++- 4 files changed, 444 insertions(+), 2 deletions(-) create mode 100644 src/providers/hypnotube.rs diff --git a/src/providers/hanime.rs b/src/providers/hanime.rs index 7141b7c..e7d03d2 100644 --- a/src/providers/hanime.rs +++ b/src/providers/hanime.rs @@ -208,7 +208,7 @@ impl HanimeProvider { .ordering(ordering); let mut requester = options.requester.clone().unwrap(); - let response = requester.post("https://search.htv-services.com/search", &search, vec![]).await.unwrap(); + let response = requester.post_json("https://search.htv-services.com/search", &search, vec![]).await.unwrap(); diff --git a/src/providers/hypnotube.rs b/src/providers/hypnotube.rs new file mode 100644 index 0000000..e4d7803 --- /dev/null +++ b/src/providers/hypnotube.rs @@ -0,0 +1,417 @@ +use crate::DbPool; +use crate::api::ClientVersion; +use crate::providers::Provider; +use crate::status::*; +use crate::util::cache::VideoCache; +use crate::util::discord::send_discord_error_report; +use crate::util::requester::Requester; +use crate::util::time::parse_time_to_seconds; +use crate::videos::{ServerOptions, VideoItem}; + +use async_trait::async_trait; +use error_chain::error_chain; +use htmlentity::entity::{decode, ICodedDataTrait}; +use std::sync::{Arc, RwLock}; +use std::{thread, vec}; +use titlecase::Titlecase; +use wreq::Version; + +error_chain! { + foreign_links { + Io(std::io::Error); + HttpRequest(wreq::Error); + Json(serde_json::Error); + } + errors { + Parse(msg: String) { + description("parse error") + display("parse error: {}", msg) + } + } +} + +#[derive(Debug, Clone)] +pub struct HypnotubeProvider { + url: String, + categories: Arc>>, +} + +impl HypnotubeProvider { + pub fn new() -> Self { + let provider = Self { + url: "https://hypnotube.com".to_string(), + categories: Arc::new(RwLock::new(vec![])), + }; + provider.spawn_initial_load(); + provider + } + + fn spawn_initial_load(&self) { + let url = self.url.clone(); + let categories = Arc::clone(&self.categories); + + thread::spawn(move || { + let rt = match tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + { + Ok(rt) => rt, + Err(e) => { + eprintln!("tokio runtime failed: {e}"); + let _ = futures::executor::block_on(send_discord_error_report( + &e, + Some("HypnoTube Provider"), + Some("Failed to create tokio runtime"), + file!(), + line!(), + module_path!(), + )); + return; + } + }; + + rt.block_on(async { + if let Err(e) = Self::load_categories(&url, Arc::clone(&categories)).await { + eprintln!("load_categories failed: {e}"); + send_discord_error_report( + &e, + Some("HypnoTube Provider"), + Some("Failed to load categories during initial load"), + file!(), + line!(), + module_path!(), + ).await; + } + }); + }); + } + + async fn load_categories(base: &str, cats: Arc>>) -> Result<()> { + let mut requester = Requester::new(); + let text = requester + .get( + &format!("{base}/channels/"), + Some(Version::HTTP_11), + ) + .await + .map_err(|e| Error::from(format!("{}", e)))?; + + let block = text + .split(" title END ") + .last() + .ok_or_else(|| ErrorKind::Parse("categories block".into()))? + .split(" main END ") + .next() + .unwrap_or(""); + + for el in block.split("").skip(1) { + let id = el + .split(" Channel { + let _ = clientversion; + Channel { + id: "hypnotube".to_string(), + name: "Hypnotube".to_string(), + description: "free video hypno tube for the sissy hypnosis porn fetish".to_string(), + premium: false, + favicon: "https://www.google.com/s2/favicons?sz=64&domain=hypnotube.com".to_string(), + status: "active".to_string(), + categories: self + .categories + .read() + .unwrap() + .iter() + .map(|c| c.title.clone()) + .collect(), + options: vec![ + ChannelOption { + id: "sort".to_string(), + title: "Sort".to_string(), + description: "Sort the Videos".to_string(), + systemImage: "list.number".to_string(), + colorName: "blue".to_string(), + options: vec![ + FilterOption { + id: "most recent".into(), + title: "Most Recent".into(), + }, + FilterOption { + id: "most viewed".into(), + title: "Most Viewed".into(), + }, + FilterOption { + id: "top rated".into(), + title: "Top Rated".into(), + }, + FilterOption { + id: "longest".into(), + title: "Longest".into(), + }, + ], + multiSelect: false, + }], + nsfw: true, + cacheDuration: Some(1800), + } + } + + fn push_unique(target: &Arc>>, item: FilterOption) { + if let Ok(mut vec) = target.write() { + if !vec.iter().any(|x| x.id == item.id) { + vec.push(item); + } + } + } + + async fn get( + &self, + cache: VideoCache, + page: u8, + sort: &str, + options: ServerOptions, + ) -> Vec { + let sort_string = match sort { + "top rated" => "top-rated", + "most viewed" => "most-viewed", + "longest" => "longest", + _ => "videos", + }; + let video_url = format!( + "{}/{}/page{}.html", + self.url, sort_string, page + ); + let old_items = match cache.get(&video_url) { + Some((time, items)) => { + if time.elapsed().unwrap_or_default().as_secs() < 60 * 5 { + return items.clone(); + } else { + items.clone() + } + } + None => { + vec![] + } + }; + let mut requester = options.requester.clone().unwrap(); + let text = requester.get(&video_url, Some(Version::HTTP_11)).await.unwrap(); + if text.contains("Sorry, no results were found.") { + eprint!("Hypnotube query returned no results for page {}", page); + return vec![]; + } + let video_items: Vec = self + .get_video_items_from_html(text.clone()) + .await; + if !video_items.is_empty() { + cache.remove(&video_url); + cache.insert(video_url.clone(), video_items.clone()); + } else { + return old_items; + } + video_items + } + + async fn query( + &self, + cache: VideoCache, + page: u8, + query: &str, + options: ServerOptions, + ) -> Vec { + let sort_string = match options.sort.as_deref().unwrap_or("") { + "top rated" => "rating", + "most viewed" => "views", + "longest" => "longest", + _ => "newest", + }; + let video_url = format!( + "{}/search/videos/{}/{}/page{}.html", + self.url, query.trim().replace(" ","%20"), sort_string, 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 items.clone(); + } else { + let _ = cache.check().await; + return items.clone(); + } + } + None => { + vec![] + } + }; + + let mut requester = options.requester.clone().unwrap(); + let text = match requester.post(format!("{}/searchgate.php", self.url).as_str(), format!("q={}&type=videos", query.replace(" ","+")).as_str(), vec![("Content-Type", "application/x-www-form-urlencoded")]).await.unwrap().text().await { + Ok(t) => t, + Err(e) => { + eprint!("Hypnotube search POST request failed: {}", e); + return vec![]; + } + }; + // println!("Hypnotube search POST response status: {}", p.text().await.unwrap_or_default()); + // let text = requester.get(&video_url, Some(Version::HTTP_11)).await.unwrap(); + if text.contains("Sorry, no results were found.") { + eprint!("Hypnotube query returned no results for page {}", page); + return vec![]; + } + let video_items: Vec = self + .get_video_items_from_html(text.clone()) + .await; + if !video_items.is_empty() { + cache.remove(&video_url); + cache.insert(video_url.clone(), video_items.clone()); + } else { + return old_items; + } + video_items + } + + async fn get_video_items_from_html( + &self, + html: String + ) -> Vec { + if html.is_empty() || html.contains("404 Not Found") { + eprint!("Hypnotube returned empty or 404 html"); + return vec![]; + } + + let block = match html + .split("pagination-col col pagination") + .next() + .and_then(|s| s.split(" title END ").last()) + { + Some(b) => b, + None => { + eprint!("Hypnotube Provider: Failed to get block from html"); + let err = Error::from(ErrorKind::Parse("html".into())); + let _ = futures::executor::block_on(send_discord_error_report( + &err, + Some("Hypnotube Provider"), + Some(&format!("Failed to get block from html:\n```{html}\n```")), + file!(), + line!(), + module_path!(), + )); + return vec![]; + }, + }; + let mut items = vec![]; + for seg in block.split("").skip(1){ + let video_url = match seg + .split(" href=\"") + .nth(1) + .and_then(|s| s.split('"').next()) { + Some(url) => url.to_string(), + None => { + eprint!("Hypnotube Provider: Failed to parse video url from segment"); + let err = Error::from(ErrorKind::Parse("video url".into())); + let _ = futures::executor::block_on(send_discord_error_report( + &err, + Some("Hypnotube Provider"), + Some(&format!("Failed to parse video url from segment:\n```{seg}\n```")), + file!(), + line!(), + module_path!(), + )); + continue; + } + }; + + let mut title = seg + .split(" title=\"") + .nth(1) + .and_then(|s| s.split('"').next()) + .unwrap_or_default().trim().to_string(); + + title = decode(title.clone().as_bytes()).to_string().unwrap_or(title).titlecase(); + let id = video_url + .split('/') + .nth(4) + .and_then(|s| s.split('.').next()) + .ok_or_else(|| ErrorKind::Parse("video id".into())) + .unwrap_or_else(|_| &title.as_str()); + let thumb = seg + .split("") + .nth(1) + .and_then(|s| s.split('<').next()) + .unwrap_or("") + .to_string(); + let duration = parse_time_to_seconds(&raw_duration).unwrap_or(0) as u32; + + let views = seg + .split("") + .nth(1) + .and_then(|s| s.split("span class=\"sub-desc\">").nth(1)) + .and_then(|s| s.split("<").next()) + .unwrap_or("0") + .replace(",", "") + .parse::() + .unwrap_or(0); + let video_item = VideoItem::new( + id.to_owned(), + title, + video_url, + "hypnotube".into(), + thumb, + duration, + ) + .views(views); + items.push(video_item); + } + items + } +} + +#[async_trait] +impl Provider for HypnotubeProvider { + async fn get_videos( + &self, + cache: VideoCache, + _pool: DbPool, + sort: String, + query: Option, + page: String, + _per_page: String, + options: ServerOptions, + ) -> Vec { + let page = page.parse::().unwrap_or(1); + + let res = match query { + Some(q) => self.to_owned().query(cache, page, &q, options).await, + None => self.get(cache, page, &sort, options).await, + }; + + return res; + } + + fn get_channel(&self, v: ClientVersion) -> Channel { + self.build_channel(v) + } +} diff --git a/src/providers/mod.rs b/src/providers/mod.rs index 85d875e..3d98a70 100644 --- a/src/providers/mod.rs +++ b/src/providers/mod.rs @@ -40,6 +40,7 @@ pub mod hqporner; pub mod noodlemagazine; pub mod pimpbunny; pub mod javtiful; +pub mod hypnotube; // convenient alias pub type DynProvider = Arc; @@ -57,6 +58,7 @@ pub static ALL_PROVIDERS: Lazy> = Lazy::new(| m.insert("noodlemagazine", Arc::new(noodlemagazine::NoodlemagazineProvider::new()) as DynProvider); m.insert("pimpbunny", Arc::new(pimpbunny::PimpbunnyProvider::new()) as DynProvider); m.insert("javtiful", Arc::new(javtiful::JavtifulProvider::new()) as DynProvider); + m.insert("hypnotube", Arc::new(hypnotube::HypnotubeProvider::new()) as DynProvider); // add more here as you migrate them m }); diff --git a/src/util/requester.rs b/src/util/requester.rs index 11bc197..3999c0e 100644 --- a/src/util/requester.rs +++ b/src/util/requester.rs @@ -111,7 +111,7 @@ impl Requester { request.send().await } - pub async fn post( +pub async fn post_json( &mut self, url: &str, data: &S, @@ -137,6 +137,29 @@ impl Requester { request.send().await } + pub async fn post( + &mut self, + url: &str, + data: &str, + headers: Vec<(&str, &str)>, + ) -> Result { + let mut request = self.client.post(url).version(Version::HTTP_11).body(data.to_string()); + + // Set custom headers + for (key, value) in headers.iter() { + request = request.header(key.to_string(), value.to_string()); + } + + if self.proxy { + if let Ok(proxy_url) = env::var("BURP_URL") { + let proxy = Proxy::all(&proxy_url).unwrap(); + request = request.proxy(proxy); + } + } + + request.send().await + } + pub async fn post_multipart( &mut self, url: &str,