510 lines
16 KiB
Rust
510 lines
16 KiB
Rust
use async_trait::async_trait;
|
|
use error_chain::error_chain;
|
|
use futures::future::join_all;
|
|
use serde_json::json;
|
|
use std::vec;
|
|
|
|
use crate::DbPool;
|
|
use crate::api::ClientVersion;
|
|
use crate::db;
|
|
use crate::providers::{Provider, report_provider_error, report_provider_error_background};
|
|
use crate::status::*;
|
|
use crate::util::cache::VideoCache;
|
|
use crate::videos::{self, ServerOptions, VideoItem};
|
|
|
|
pub const CHANNEL_METADATA: crate::providers::ProviderChannelMetadata =
|
|
crate::providers::ProviderChannelMetadata {
|
|
group_id: "hentai-animation",
|
|
tags: &["hentai", "anime", "premium"],
|
|
};
|
|
|
|
error_chain! {
|
|
foreign_links {
|
|
Io(std::io::Error);
|
|
HttpRequest(wreq::Error);
|
|
}
|
|
}
|
|
|
|
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
|
|
struct HanimeSearchRequest {
|
|
search_text: String,
|
|
tags: Vec<String>,
|
|
tags_mode: String,
|
|
brands: Vec<String>,
|
|
blacklist: Vec<String>,
|
|
order_by: String,
|
|
ordering: String,
|
|
page: u8,
|
|
}
|
|
|
|
impl HanimeSearchRequest {
|
|
pub fn new() -> Self {
|
|
HanimeSearchRequest {
|
|
search_text: "".to_string(),
|
|
tags: vec![],
|
|
tags_mode: "AND".to_string(),
|
|
brands: vec![],
|
|
blacklist: vec![],
|
|
order_by: "created_at_unix".to_string(),
|
|
ordering: "desc".to_string(),
|
|
page: 0,
|
|
}
|
|
}
|
|
pub fn search_text(mut self, search_text: String) -> Self {
|
|
self.search_text = search_text;
|
|
self
|
|
}
|
|
pub fn order_by(mut self, order_by: String) -> Self {
|
|
self.order_by = order_by;
|
|
self
|
|
}
|
|
pub fn ordering(mut self, ordering: String) -> Self {
|
|
self.ordering = ordering;
|
|
self
|
|
}
|
|
pub fn page(mut self, page: u8) -> Self {
|
|
self.page = page;
|
|
self
|
|
}
|
|
}
|
|
|
|
#[derive(serde::Serialize, serde::Deserialize, Debug)]
|
|
struct HanimeSearchResponse {
|
|
page: u8,
|
|
nbPages: u8,
|
|
nbHits: u32,
|
|
hitsPerPage: u8,
|
|
hits: String,
|
|
}
|
|
|
|
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
|
|
struct HanimeSearchResult {
|
|
id: u64,
|
|
name: String,
|
|
titles: Vec<String>,
|
|
slug: String,
|
|
description: String,
|
|
views: u64,
|
|
interests: u64,
|
|
poster_url: String,
|
|
cover_url: String,
|
|
brand: String,
|
|
brand_id: u64,
|
|
duration_in_ms: u32,
|
|
is_censored: bool,
|
|
rating: Option<u32>,
|
|
likes: u64,
|
|
dislikes: u64,
|
|
downloads: u64,
|
|
monthly_ranked: Option<u64>,
|
|
tags: Vec<String>,
|
|
created_at: u64,
|
|
released_at: u64,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct HanimeProvider;
|
|
|
|
impl HanimeProvider {
|
|
pub fn new() -> Self {
|
|
HanimeProvider
|
|
}
|
|
|
|
fn build_channel(&self, _clientversion: ClientVersion) -> Channel {
|
|
Channel {
|
|
id: "hanime".to_string(),
|
|
name: "Hanime".to_string(),
|
|
description: "Free Hentai from Hanime".to_string(),
|
|
premium: false,
|
|
favicon: "https://www.google.com/s2/favicons?sz=64&domain=hanime.tv".to_string(),
|
|
status: "active".to_string(),
|
|
categories: vec![],
|
|
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: "created_at_unix.desc".to_string(),
|
|
title: "Recent Upload".to_string(),
|
|
},
|
|
FilterOption {
|
|
id: "created_at_unix.asc".to_string(),
|
|
title: "Old Upload".to_string(),
|
|
},
|
|
FilterOption {
|
|
id: "views.desc".to_string(),
|
|
title: "Most Views".to_string(),
|
|
},
|
|
FilterOption {
|
|
id: "views.asc".to_string(),
|
|
title: "Least Views".to_string(),
|
|
},
|
|
FilterOption {
|
|
id: "likes.desc".to_string(),
|
|
title: "Most Likes".to_string(),
|
|
},
|
|
FilterOption {
|
|
id: "likes.asc".to_string(),
|
|
title: "Least Likes".to_string(),
|
|
},
|
|
FilterOption {
|
|
id: "released_at_unix.desc".to_string(),
|
|
title: "New".to_string(),
|
|
},
|
|
FilterOption {
|
|
id: "released_at_unix.asc".to_string(),
|
|
title: "Old".to_string(),
|
|
},
|
|
FilterOption {
|
|
id: "title_sortable.asc".to_string(),
|
|
title: "A - Z".to_string(),
|
|
},
|
|
FilterOption {
|
|
id: "title_sortable.desc".to_string(),
|
|
title: "Z - A".to_string(),
|
|
},
|
|
],
|
|
multiSelect: false,
|
|
}],
|
|
nsfw: true,
|
|
cacheDuration: None,
|
|
}
|
|
}
|
|
|
|
async fn get_video_item(
|
|
&self,
|
|
hit: HanimeSearchResult,
|
|
pool: DbPool,
|
|
options: ServerOptions,
|
|
) -> Result<VideoItem> {
|
|
let mut conn = match pool.get() {
|
|
Ok(conn) => conn,
|
|
Err(e) => {
|
|
report_provider_error("hanime", "get_video_item.pool_get", &e.to_string()).await;
|
|
return Err(Error::from("Failed to get DB connection"));
|
|
}
|
|
};
|
|
let db_result = db::get_video(
|
|
&mut conn,
|
|
format!(
|
|
"https://h.freeanimehentai.net/api/v8/video?id={}&",
|
|
hit.slug.clone()
|
|
),
|
|
);
|
|
drop(conn);
|
|
let id = hit.id.to_string();
|
|
let title = hit.name;
|
|
let thumb = crate::providers::build_proxy_url(
|
|
&options,
|
|
"hanime-cdn",
|
|
&crate::providers::strip_url_scheme(&hit.cover_url),
|
|
);
|
|
let duration = (hit.duration_in_ms / 1000) as u32; // Convert ms to seconds
|
|
let channel = "hanime".to_string(); // Placeholder, adjust as needed
|
|
match db_result {
|
|
Ok(Some(video_url)) => {
|
|
if video_url != "https://streamable.cloud/hls/stream.m3u8" {
|
|
return Ok(VideoItem::new(
|
|
id,
|
|
title,
|
|
video_url.clone(),
|
|
channel,
|
|
thumb,
|
|
duration,
|
|
)
|
|
.tags(hit.tags)
|
|
.uploader(hit.brand)
|
|
.views(hit.views as u32)
|
|
.rating((hit.likes as f32 / (hit.likes + hit.dislikes) as f32) * 100 as f32)
|
|
.aspect_ratio(0.68)
|
|
.formats(vec![videos::VideoFormat::new(
|
|
video_url.clone(),
|
|
"1080".to_string(),
|
|
"m3u8".to_string(),
|
|
)]));
|
|
} else {
|
|
match pool.get() {
|
|
Ok(mut conn) => {
|
|
let _ = db::delete_video(
|
|
&mut conn,
|
|
format!(
|
|
"https://h.freeanimehentai.net/api/v8/video?id={}&",
|
|
hit.slug.clone()
|
|
),
|
|
);
|
|
}
|
|
Err(e) => {
|
|
report_provider_error_background(
|
|
"hanime",
|
|
"get_video_item.delete_video.pool_get",
|
|
&e.to_string(),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(None) => (),
|
|
Err(e) => {
|
|
println!("Error fetching video from database: {}", e);
|
|
// return Err(format!("Error fetching video from database: {}", e).into());
|
|
}
|
|
}
|
|
let url = format!(
|
|
"https://cached.freeanimehentai.net/api/v8/guest/videos/{}/manifest",
|
|
id
|
|
);
|
|
|
|
let mut requester =
|
|
crate::providers::requester_or_default(&options, module_path!(), "missing_requester");
|
|
let payload = json!({
|
|
"width": 571, "height": 703, "ab": "kh" }
|
|
);
|
|
let _ = requester
|
|
.post_json(
|
|
&format!(
|
|
"https://cached.freeanimehentai.net/api/v8/hentai_videos/{}/play",
|
|
hit.slug
|
|
),
|
|
&payload,
|
|
vec![
|
|
("Origin".to_string(), "https://hanime.tv".to_string()),
|
|
("Referer".to_string(), "https://hanime.tv/".to_string()),
|
|
],
|
|
)
|
|
.await; // Initial request to set cookies
|
|
ntex::time::sleep(ntex::time::Seconds(1)).await;
|
|
let text = requester
|
|
.get_raw_with_headers(
|
|
&url,
|
|
vec![
|
|
("Origin".to_string(), "https://hanime.tv".to_string()),
|
|
("Referer".to_string(), "https://hanime.tv/".to_string()),
|
|
],
|
|
)
|
|
.await
|
|
.map_err(|e| {
|
|
report_provider_error_background(
|
|
"hanime",
|
|
"get_video_item.get_raw_with_headers",
|
|
&e.to_string(),
|
|
);
|
|
Error::from(format!("Failed to fetch manifest response: {e}"))
|
|
})?
|
|
.text()
|
|
.await
|
|
.map_err(|e| {
|
|
report_provider_error_background(
|
|
"hanime",
|
|
"get_video_item.response_text",
|
|
&e.to_string(),
|
|
);
|
|
Error::from(format!("Failed to decode manifest response body: {e}"))
|
|
})?;
|
|
if text.contains("Unautho") {
|
|
println!("Fetched video details for {}: {}", title, text);
|
|
return Err(Error::from("Unauthorized"));
|
|
}
|
|
let urls = text
|
|
.split("streams")
|
|
.nth(1)
|
|
.ok_or_else(|| Error::from("Missing streams section in manifest"))?;
|
|
let mut url_vec = vec![];
|
|
|
|
for el in urls.split("\"url\":\"").collect::<Vec<&str>>() {
|
|
let url = el
|
|
.split("\"")
|
|
.collect::<Vec<&str>>()
|
|
.get(0)
|
|
.copied()
|
|
.unwrap_or_default();
|
|
if !url.is_empty() && url.contains("m3u8") {
|
|
url_vec.push(url.to_string());
|
|
}
|
|
}
|
|
let first_url = url_vec
|
|
.first()
|
|
.cloned()
|
|
.ok_or_else(|| Error::from("No stream URL found in manifest"))?;
|
|
match pool.get() {
|
|
Ok(mut conn) => {
|
|
let _ = db::insert_video(
|
|
&mut conn,
|
|
&format!(
|
|
"https://h.freeanimehentai.net/api/v8/video?id={}&",
|
|
hit.slug.clone()
|
|
),
|
|
&first_url,
|
|
);
|
|
}
|
|
Err(e) => {
|
|
report_provider_error_background(
|
|
"hanime",
|
|
"get_video_item.insert_video.pool_get",
|
|
&e.to_string(),
|
|
);
|
|
}
|
|
}
|
|
Ok(
|
|
VideoItem::new(id, title, first_url.clone(), channel, thumb, duration)
|
|
.tags(hit.tags)
|
|
.uploader(hit.brand)
|
|
.views(hit.views as u32)
|
|
.rating((hit.likes as f32 / (hit.likes + hit.dislikes) as f32) * 100 as f32)
|
|
.formats(vec![videos::VideoFormat::new(
|
|
first_url,
|
|
"1080".to_string(),
|
|
"m3u8".to_string(),
|
|
)]),
|
|
)
|
|
}
|
|
|
|
async fn get(
|
|
&self,
|
|
cache: VideoCache,
|
|
pool: DbPool,
|
|
page: u8,
|
|
query: String,
|
|
sort: String,
|
|
options: ServerOptions,
|
|
) -> Result<Vec<VideoItem>> {
|
|
let index = format!("hanime:{}:{}:{}", query, page, sort);
|
|
let order_by = match sort.contains(".") {
|
|
true => sort
|
|
.split(".")
|
|
.collect::<Vec<&str>>()
|
|
.get(0)
|
|
.copied()
|
|
.unwrap_or_default()
|
|
.to_string(),
|
|
false => "created_at_unix".to_string(),
|
|
};
|
|
let ordering = match sort.contains(".") {
|
|
true => sort
|
|
.split(".")
|
|
.collect::<Vec<&str>>()
|
|
.get(1)
|
|
.copied()
|
|
.unwrap_or_default()
|
|
.to_string(),
|
|
false => "desc".to_string(),
|
|
};
|
|
let old_items = match cache.get(&index) {
|
|
Some((time, items)) => {
|
|
if time.elapsed().unwrap_or_default().as_secs() < 1 {
|
|
//println!("Cache hit for URL: {}", index);
|
|
return Ok(items.clone());
|
|
} else {
|
|
items.clone()
|
|
}
|
|
}
|
|
None => {
|
|
vec![]
|
|
}
|
|
};
|
|
|
|
let search = HanimeSearchRequest::new()
|
|
.page(page - 1)
|
|
.search_text(query.clone())
|
|
.order_by(order_by)
|
|
.ordering(ordering);
|
|
|
|
let mut requester =
|
|
crate::providers::requester_or_default(&options, module_path!(), "missing_requester");
|
|
let response = match requester
|
|
.post_json("https://search.htv-services.com/search", &search, vec![])
|
|
.await
|
|
{
|
|
Ok(response) => response,
|
|
Err(e) => {
|
|
report_provider_error(
|
|
"hanime",
|
|
"get.search_request",
|
|
&format!("query={query}; page={page}; error={e}"),
|
|
)
|
|
.await;
|
|
return Ok(old_items);
|
|
}
|
|
};
|
|
|
|
let hits = match response.json::<HanimeSearchResponse>().await {
|
|
Ok(resp) => resp.hits,
|
|
Err(e) => {
|
|
println!("Failed to parse HanimeSearchResponse: {}", e);
|
|
return Ok(old_items);
|
|
}
|
|
};
|
|
let hits_json: Vec<HanimeSearchResult> = serde_json::from_str(hits.as_str())
|
|
.map_err(|e| format!("Failed to parse hits JSON: {}", e))?;
|
|
// let timeout_duration = Duration::from_secs(120);
|
|
let futures = hits_json
|
|
.into_iter()
|
|
.map(|el| self.get_video_item(el.clone(), pool.clone(), options.clone()));
|
|
let results: Vec<Result<VideoItem>> = join_all(futures).await;
|
|
let video_items: Vec<VideoItem> = results.into_iter().filter_map(Result::ok).collect();
|
|
if !video_items.is_empty() {
|
|
cache.remove(&index);
|
|
cache.insert(index.clone(), video_items.clone());
|
|
} else {
|
|
return Ok(old_items);
|
|
}
|
|
|
|
Ok(video_items)
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl Provider for HanimeProvider {
|
|
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.get(
|
|
cache,
|
|
pool,
|
|
page.parse::<u8>().unwrap_or(1),
|
|
q,
|
|
sort,
|
|
options,
|
|
)
|
|
.await
|
|
}
|
|
None => {
|
|
self.get(
|
|
cache,
|
|
pool,
|
|
page.parse::<u8>().unwrap_or(1),
|
|
"".to_string(),
|
|
sort,
|
|
options,
|
|
)
|
|
.await
|
|
}
|
|
};
|
|
match videos {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
println!("Error fetching videos: {}", e);
|
|
vec![]
|
|
}
|
|
}
|
|
}
|
|
|
|
fn get_channel(&self, clientversion: ClientVersion) -> Option<Channel> {
|
|
Some(self.build_channel(clientversion))
|
|
}
|
|
}
|