645 lines
22 KiB
Rust
645 lines
22 KiB
Rust
use aes_gcm::aead::{Aead, KeyInit, Payload};
|
|
use aes_gcm::{Aes256Gcm, Key, Nonce};
|
|
use async_trait::async_trait;
|
|
use base64::Engine;
|
|
use error_chain::error_chain;
|
|
use futures::future::join_all;
|
|
use serde_json::json;
|
|
use sha2::{Digest, Sha256};
|
|
use std::sync::{Arc, Mutex, OnceLock};
|
|
use std::time::{SystemTime, UNIX_EPOCH};
|
|
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);
|
|
}
|
|
}
|
|
|
|
/// Full catalogue dump. Ignores every query parameter, so filtering, sorting and
|
|
/// pagination all happen client side. ~860 KB compressed, CDN cached for an hour.
|
|
const INDEX_URL: &str = "https://guest.freeanimehentai.net/api/v11/search_hvs";
|
|
const HANDSHAKE_URL: &str = "https://auth.hanime.tv/api/v11/handshake";
|
|
const SITE_ORIGIN: &str = "https://hanime.tv";
|
|
/// Envelope encryption used for the handshake request/response bodies.
|
|
const HANDSHAKE_KEY_SEED: &[u8] = b"htv-insecure-handshake-v1";
|
|
const HANDSHAKE_AAD: &[u8] = b"htv-insecure-v1";
|
|
/// Pieces of the `x-signature` pre-image, as baked into the site's wasm module.
|
|
const SIGNATURE_SECRET: &str = "Xkdi29";
|
|
const SIGNATURE_SALT: &str = "mn2";
|
|
const INDEX_TTL_SECS: u64 = 3600;
|
|
|
|
type IndexCache = OnceLock<Mutex<Option<(SystemTime, Arc<Vec<HanimeSearchResult>>)>>>;
|
|
static INDEX_CACHE: IndexCache = OnceLock::new();
|
|
|
|
#[derive(serde::Deserialize, Debug)]
|
|
struct HanimeIndexResponse {
|
|
data: Vec<HanimeSearchResult>,
|
|
}
|
|
|
|
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
|
|
struct HanimeSearchResult {
|
|
id: u64,
|
|
name: String,
|
|
#[serde(default)]
|
|
search_titles: String,
|
|
slug: String,
|
|
#[serde(default)]
|
|
views: u64,
|
|
cover_url: String,
|
|
#[serde(default)]
|
|
brand: String,
|
|
#[serde(default)]
|
|
likes: u64,
|
|
#[serde(default)]
|
|
dislikes: u64,
|
|
#[serde(default)]
|
|
tags: Vec<String>,
|
|
#[serde(default)]
|
|
created_at_unix: u64,
|
|
#[serde(default)]
|
|
released_at_unix: u64,
|
|
}
|
|
|
|
#[derive(serde::Deserialize, Debug)]
|
|
struct HanimeHandshakePayload {
|
|
#[serde(default)]
|
|
sources: Vec<HanimeSource>,
|
|
}
|
|
|
|
#[derive(serde::Deserialize, Debug, Clone)]
|
|
struct HanimeSource {
|
|
#[serde(default)]
|
|
src: String,
|
|
#[serde(default)]
|
|
height: u32,
|
|
#[serde(default)]
|
|
label: String,
|
|
/// `"normal"` for the free streams, `"promotion"` for the premium-only teaser
|
|
/// entries which always carry an empty `src`.
|
|
#[serde(default)]
|
|
kind: String,
|
|
}
|
|
|
|
fn b64() -> base64::engine::general_purpose::GeneralPurpose {
|
|
base64::engine::general_purpose::URL_SAFE_NO_PAD
|
|
}
|
|
|
|
fn b64_decode(value: &str) -> Result<Vec<u8>> {
|
|
b64()
|
|
.decode(value.trim_end_matches('='))
|
|
.map_err(|e| Error::from(format!("base64url decode failed: {e}")))
|
|
}
|
|
|
|
fn handshake_cipher() -> Aes256Gcm {
|
|
let digest = Sha256::digest(HANDSHAKE_KEY_SEED);
|
|
let key = Key::<Aes256Gcm>::from_slice(digest.as_slice());
|
|
Aes256Gcm::new(key)
|
|
}
|
|
|
|
/// `{"v":1,"alg":"AES-256-GCM","iv":..,"tag":..,"data":..}`, base64url encoded.
|
|
fn seal_envelope(plaintext: &[u8]) -> Result<String> {
|
|
let mut iv = [0u8; 12];
|
|
rand::fill(&mut iv);
|
|
let sealed = handshake_cipher()
|
|
.encrypt(
|
|
Nonce::from_slice(&iv),
|
|
Payload {
|
|
msg: plaintext,
|
|
aad: HANDSHAKE_AAD,
|
|
},
|
|
)
|
|
.map_err(|e| Error::from(format!("handshake encrypt failed: {e}")))?;
|
|
if sealed.len() < 16 {
|
|
return Err(Error::from("handshake ciphertext too short"));
|
|
}
|
|
let (data, tag) = sealed.split_at(sealed.len() - 16);
|
|
let envelope = json!({
|
|
"v": 1,
|
|
"alg": "AES-256-GCM",
|
|
"iv": b64().encode(iv),
|
|
"tag": b64().encode(tag),
|
|
"data": b64().encode(data),
|
|
});
|
|
Ok(b64().encode(envelope.to_string().as_bytes()))
|
|
}
|
|
|
|
fn open_envelope(token: &str) -> Result<Vec<u8>> {
|
|
let envelope: serde_json::Value = serde_json::from_slice(&b64_decode(token)?)
|
|
.map_err(|e| Error::from(format!("handshake envelope is not JSON: {e}")))?;
|
|
let field = |name: &str| -> Result<Vec<u8>> {
|
|
let raw = envelope
|
|
.get(name)
|
|
.and_then(|v| v.as_str())
|
|
.ok_or_else(|| Error::from(format!("handshake envelope missing {name}")))?;
|
|
b64_decode(raw)
|
|
};
|
|
let iv = field("iv")?;
|
|
let mut ciphertext = field("data")?;
|
|
ciphertext.extend_from_slice(&field("tag")?);
|
|
handshake_cipher()
|
|
.decrypt(
|
|
Nonce::from_slice(&iv),
|
|
Payload {
|
|
msg: &ciphertext,
|
|
aad: HANDSHAKE_AAD,
|
|
},
|
|
)
|
|
.map_err(|e| Error::from(format!("handshake decrypt failed: {e}")))
|
|
}
|
|
|
|
fn signature_for(timestamp: u64) -> String {
|
|
let pre_image =
|
|
format!("{timestamp},{SIGNATURE_SECRET},{SITE_ORIGIN},{SIGNATURE_SALT},{timestamp}");
|
|
hex::encode(Sha256::digest(pre_image.as_bytes()))
|
|
}
|
|
|
|
#[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,
|
|
ytdlpCommand: Some("yt-dlp --impersonate chrome-120".to_string()),
|
|
}
|
|
}
|
|
|
|
fn db_key(slug: &str) -> String {
|
|
format!("https://hanime.tv/videos/hentai/{slug}")
|
|
}
|
|
|
|
fn build_video_item(
|
|
hit: &HanimeSearchResult,
|
|
video_url: String,
|
|
thumb: String,
|
|
duration: u32,
|
|
formats: Vec<videos::VideoFormat>,
|
|
) -> VideoItem {
|
|
let votes = hit.likes + hit.dislikes;
|
|
let rating = match votes {
|
|
0 => 0_f32,
|
|
_ => (hit.likes as f32 / votes as f32) * 100_f32,
|
|
};
|
|
VideoItem::new(
|
|
hit.id.to_string(),
|
|
hit.name.clone(),
|
|
video_url,
|
|
"hanime".to_string(),
|
|
thumb,
|
|
duration,
|
|
)
|
|
.tags(hit.tags.clone())
|
|
.uploader(hit.brand.clone())
|
|
.views(hit.views as u32)
|
|
.rating(rating)
|
|
.aspect_ratio(0.68)
|
|
.formats(formats)
|
|
}
|
|
|
|
/// The whole catalogue in one document, memoised for an hour to match the CDN.
|
|
async fn fetch_index(&self, options: &ServerOptions) -> Result<Arc<Vec<HanimeSearchResult>>> {
|
|
let cell = INDEX_CACHE.get_or_init(|| Mutex::new(None));
|
|
if let Ok(guard) = cell.lock() {
|
|
if let Some((fetched_at, items)) = guard.as_ref() {
|
|
if fetched_at.elapsed().unwrap_or_default().as_secs() < INDEX_TTL_SECS {
|
|
return Ok(items.clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
let mut requester =
|
|
crate::providers::requester_or_default(options, module_path!(), "missing_requester");
|
|
let response = requester
|
|
.get_raw_with_headers(
|
|
INDEX_URL,
|
|
vec![
|
|
("Origin".to_string(), SITE_ORIGIN.to_string()),
|
|
("Referer".to_string(), format!("{SITE_ORIGIN}/")),
|
|
("Accept".to_string(), "application/json".to_string()),
|
|
],
|
|
)
|
|
.await
|
|
.map_err(|e| Error::from(format!("Failed to fetch hanime index: {e}")))?;
|
|
|
|
let status = response.status();
|
|
if !status.is_success() {
|
|
return Err(Error::from(format!("hanime index returned HTTP {status}")));
|
|
}
|
|
|
|
let parsed: HanimeIndexResponse = response
|
|
.json()
|
|
.await
|
|
.map_err(|e| Error::from(format!("Failed to parse hanime index: {e}")))?;
|
|
if parsed.data.is_empty() {
|
|
return Err(Error::from("hanime index was empty"));
|
|
}
|
|
|
|
let items = Arc::new(parsed.data);
|
|
if let Ok(mut guard) = cell.lock() {
|
|
*guard = Some((SystemTime::now(), items.clone()));
|
|
}
|
|
Ok(items)
|
|
}
|
|
|
|
/// Returns the free `sources` for a slug, best quality first. The auth host
|
|
/// occasionally refuses one of a burst of parallel connections, so retry once.
|
|
async fn fetch_sources(&self, slug: &str, options: &ServerOptions) -> Result<Vec<HanimeSource>> {
|
|
match self.handshake(slug, options).await {
|
|
Ok(sources) => Ok(sources),
|
|
Err(_) => {
|
|
ntex::time::sleep(ntex::time::Millis(500)).await;
|
|
self.handshake(slug, options).await
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn handshake(&self, slug: &str, options: &ServerOptions) -> Result<Vec<HanimeSource>> {
|
|
let timestamp = SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.unwrap_or_default()
|
|
.as_secs();
|
|
let token = seal_envelope(
|
|
json!({
|
|
"timestamp_unix": timestamp,
|
|
"directive": "htv_player_handshake",
|
|
"slug": slug,
|
|
})
|
|
.to_string()
|
|
.as_bytes(),
|
|
)?;
|
|
|
|
let mut requester =
|
|
crate::providers::requester_or_default(options, module_path!(), "missing_requester");
|
|
let response = requester
|
|
.post_json(
|
|
HANDSHAKE_URL,
|
|
&json!({ "token": token }),
|
|
vec![
|
|
("Origin".to_string(), SITE_ORIGIN.to_string()),
|
|
("Referer".to_string(), format!("{SITE_ORIGIN}/")),
|
|
("Accept".to_string(), "application/json".to_string()),
|
|
("x-signature-version".to_string(), "web2".to_string()),
|
|
("x-signature".to_string(), signature_for(timestamp)),
|
|
("x-time".to_string(), timestamp.to_string()),
|
|
],
|
|
)
|
|
.await
|
|
.map_err(|e| Error::from(format!("handshake request failed: {e}")))?;
|
|
|
|
let status = response.status();
|
|
if !status.is_success() {
|
|
return Err(Error::from(format!("handshake returned HTTP {status}")));
|
|
}
|
|
|
|
// The interesting part of the answer travels in a response header, not the body.
|
|
let encrypted = response
|
|
.headers()
|
|
.get("x-token")
|
|
.and_then(|v| v.to_str().ok())
|
|
.map(|v| v.to_string())
|
|
.ok_or_else(|| Error::from("handshake response is missing x-token"))?;
|
|
|
|
let payload: HanimeHandshakePayload = serde_json::from_slice(&open_envelope(&encrypted)?)
|
|
.map_err(|e| Error::from(format!("Failed to parse handshake payload: {e}")))?;
|
|
|
|
let mut sources: Vec<HanimeSource> = payload
|
|
.sources
|
|
.into_iter()
|
|
.filter(|s| s.kind == "normal" && !s.src.is_empty())
|
|
.collect();
|
|
sources.sort_by(|a, b| b.height.cmp(&a.height));
|
|
match sources.is_empty() {
|
|
true => Err(Error::from("handshake returned no playable sources")),
|
|
false => Ok(sources),
|
|
}
|
|
}
|
|
|
|
fn source_url(source: &HanimeSource) -> String {
|
|
match source.src.starts_with("http") {
|
|
true => source.src.clone(),
|
|
false => format!("{SITE_ORIGIN}{}", source.src),
|
|
}
|
|
}
|
|
|
|
fn quality_label(source: &HanimeSource) -> String {
|
|
match source.label.trim_end_matches('p') {
|
|
"" => source.height.to_string(),
|
|
label => label.to_string(),
|
|
}
|
|
}
|
|
|
|
/// The catalogue no longer carries a duration, so derive it from the playlist.
|
|
/// Doubles as proof that the URL we are about to hand out actually serves 200.
|
|
async fn fetch_duration(&self, url: &str, options: &ServerOptions) -> Result<u32> {
|
|
let mut requester =
|
|
crate::providers::requester_or_default(options, module_path!(), "missing_requester");
|
|
let response = requester
|
|
.get_raw(url)
|
|
.await
|
|
.map_err(|e| Error::from(format!("Failed to fetch playlist: {e}")))?;
|
|
let status = response.status();
|
|
if !status.is_success() {
|
|
return Err(Error::from(format!("playlist returned HTTP {status}")));
|
|
}
|
|
let playlist = response
|
|
.text()
|
|
.await
|
|
.map_err(|e| Error::from(format!("Failed to decode playlist: {e}")))?;
|
|
|
|
let seconds: f64 = playlist
|
|
.lines()
|
|
.filter_map(|line| line.strip_prefix("#EXTINF:"))
|
|
.filter_map(|value| value.split(',').next())
|
|
.filter_map(|value| value.trim().parse::<f64>().ok())
|
|
.sum();
|
|
Ok(seconds.round() as u32)
|
|
}
|
|
|
|
async fn get_video_item(
|
|
&self,
|
|
hit: HanimeSearchResult,
|
|
pool: DbPool,
|
|
options: ServerOptions,
|
|
) -> Result<VideoItem> {
|
|
let thumb = crate::providers::build_proxy_url(
|
|
&options,
|
|
"hanime-cdn",
|
|
&crate::providers::strip_url_scheme(&hit.cover_url),
|
|
);
|
|
let db_key = Self::db_key(&hit.slug);
|
|
|
|
match self.fetch_sources(&hit.slug, &options).await {
|
|
Ok(sources) => {
|
|
let formats: Vec<videos::VideoFormat> = sources
|
|
.iter()
|
|
.map(|source| {
|
|
videos::VideoFormat::new(
|
|
Self::source_url(source),
|
|
Self::quality_label(source),
|
|
"m3u8".to_string(),
|
|
)
|
|
})
|
|
.collect();
|
|
let stream_url = Self::source_url(&sources[0]);
|
|
let duration = self
|
|
.fetch_duration(&stream_url, &options)
|
|
.await
|
|
.unwrap_or_default();
|
|
if let Ok(mut conn) = pool.get() {
|
|
let _ = db::insert_video(&mut conn, &db_key, &stream_url);
|
|
}
|
|
return Ok(Self::build_video_item(
|
|
&hit,
|
|
stream_url,
|
|
thumb,
|
|
duration,
|
|
formats,
|
|
));
|
|
}
|
|
Err(e) => {
|
|
report_provider_error_background(
|
|
"hanime",
|
|
"get_video_item.fetch_sources",
|
|
&format!("slug={}; error={e}", hit.slug),
|
|
);
|
|
}
|
|
}
|
|
|
|
// API failed — fall back to DB
|
|
let db_result = pool
|
|
.get()
|
|
.ok()
|
|
.and_then(|mut conn| db::get_video(&mut conn, db_key.clone()).ok().flatten());
|
|
|
|
match db_result {
|
|
Some(video_url) if video_url.contains("m3u8") || video_url.contains("/hls/") => {
|
|
let duration = self
|
|
.fetch_duration(&video_url, &options)
|
|
.await
|
|
.unwrap_or_default();
|
|
let formats = vec![videos::VideoFormat::new(
|
|
video_url.clone(),
|
|
"720".to_string(),
|
|
"m3u8".to_string(),
|
|
)];
|
|
Ok(Self::build_video_item(
|
|
&hit, video_url, thumb, duration, formats,
|
|
))
|
|
}
|
|
Some(_) => {
|
|
if let Ok(mut conn) = pool.get() {
|
|
let _ = db::delete_video(&mut conn, db_key);
|
|
}
|
|
Err(Error::from("Stale DB entry and API unavailable"))
|
|
}
|
|
None => Err(Error::from("API unavailable and no DB fallback")),
|
|
}
|
|
}
|
|
|
|
fn matches_query(hit: &HanimeSearchResult, query: &str) -> bool {
|
|
if query.is_empty() {
|
|
return true;
|
|
}
|
|
hit.name.to_lowercase().contains(query)
|
|
|| hit.search_titles.to_lowercase().contains(query)
|
|
|| hit.brand.to_lowercase().contains(query)
|
|
|| hit.tags.iter().any(|tag| tag.to_lowercase().contains(query))
|
|
}
|
|
|
|
fn sort_hits(hits: &mut [HanimeSearchResult], order_by: &str, ordering: &str) {
|
|
match order_by {
|
|
"title_sortable" => hits.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase())),
|
|
"views" => hits.sort_by(|a, b| a.views.cmp(&b.views)),
|
|
"likes" => hits.sort_by(|a, b| a.likes.cmp(&b.likes)),
|
|
"released_at_unix" => hits.sort_by(|a, b| a.released_at_unix.cmp(&b.released_at_unix)),
|
|
_ => hits.sort_by(|a, b| a.created_at_unix.cmp(&b.created_at_unix)),
|
|
}
|
|
if ordering != "asc" {
|
|
hits.reverse();
|
|
}
|
|
}
|
|
|
|
async fn get(
|
|
&self,
|
|
cache: VideoCache,
|
|
pool: DbPool,
|
|
page: u32,
|
|
per_page: usize,
|
|
query: String,
|
|
sort: String,
|
|
options: ServerOptions,
|
|
) -> Result<Vec<VideoItem>> {
|
|
let index = format!("hanime:{query}:{page}:{per_page}:{sort}");
|
|
let (order_by, ordering) = match sort.split_once('.') {
|
|
Some((order_by, ordering)) => (order_by.to_string(), ordering.to_string()),
|
|
None => ("created_at_unix".to_string(), "desc".to_string()),
|
|
};
|
|
let old_items = match cache.get(&index) {
|
|
Some((time, items)) => {
|
|
if time.elapsed().unwrap_or_default().as_secs() < 1 {
|
|
return Ok(items.clone());
|
|
}
|
|
items.clone()
|
|
}
|
|
None => vec![],
|
|
};
|
|
|
|
let catalogue = match self.fetch_index(&options).await {
|
|
Ok(catalogue) => catalogue,
|
|
Err(e) => {
|
|
report_provider_error(
|
|
"hanime",
|
|
"get.fetch_index",
|
|
&format!("query={query}; page={page}; error={e}"),
|
|
)
|
|
.await;
|
|
return Ok(old_items);
|
|
}
|
|
};
|
|
|
|
// The upstream dump ignores every query parameter, so search, sort and
|
|
// pagination are applied here.
|
|
let needle = query.trim().to_lowercase();
|
|
let mut hits: Vec<HanimeSearchResult> = catalogue
|
|
.iter()
|
|
.filter(|hit| Self::matches_query(hit, &needle))
|
|
.cloned()
|
|
.collect();
|
|
Self::sort_hits(&mut hits, &order_by, &ordering);
|
|
|
|
let offset = (page.saturating_sub(1) as usize).saturating_mul(per_page);
|
|
let hits: Vec<HanimeSearchResult> = hits.into_iter().skip(offset).take(per_page).collect();
|
|
if hits.is_empty() {
|
|
return Ok(vec![]);
|
|
}
|
|
|
|
let futures = hits
|
|
.into_iter()
|
|
.map(|el| self.get_video_item(el, 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() {
|
|
return Ok(old_items);
|
|
}
|
|
cache.remove(&index);
|
|
cache.insert(index.clone(), video_items.clone());
|
|
|
|
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 videos = self
|
|
.get(
|
|
cache,
|
|
pool,
|
|
page.parse::<u32>().unwrap_or(1).max(1),
|
|
per_page.parse::<usize>().unwrap_or(20).clamp(1, 100),
|
|
query.unwrap_or_default(),
|
|
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))
|
|
}
|
|
}
|