euzu/tuliprox
1
0
Fork 0
mirror of https://github.com/euzu/tuliprox.git synced 2026-10-10 01:42:30 +02:00
Code Issues Packages Projects Releases 5 Wiki Activity

Replaced actix with axum

Browse Source
This commit is contained in:
euzu
2025-03-11 16:07:06 +01:00
parent 988f87173e
commit fe50ecbb23
60 changed files with 1774 additions and 1934 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/processing/parser/xtream.rs
+47 -51
View File
@@ -1,7 +1,5 @@
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
use std::sync::Arc;
use serde_json::Value;
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind, create_m3u_filter_error_result};
@@ -29,13 +27,13 @@ fn map_to_xtream_streams(xtream_cluster: XtreamCluster, streams: &Value) -> Resu
}
}
fn create_xtream_series_episode_url(url: &str, username: &str, password: &str, episode: &XtreamSeriesInfoEpisode) -> Rc<String> {
fn create_xtream_series_episode_url(url: &str, username: &str, password: &str, episode: &XtreamSeriesInfoEpisode) -> Arc<String> {
if episode.direct_source.is_empty() {
let ext = episode.container_extension.clone();
let stream_base_url = format!("{url}/series/{username}/{password}/{}.{ext}", episode.id);
Rc::new(stream_base_url)
Arc::new(stream_base_url)
} else {
Rc::new(episode.direct_source.clone())
Arc::new(episode.direct_source.clone())
}
}
@@ -51,21 +49,21 @@ pub fn parse_xtream_series_info(info: &Value, group_title: &str, series_name: &s
let episode_url = create_xtream_series_episode_url(url, username, password, episode);
(episode.clone(),
PlaylistItem {
header: RefCell::new(PlaylistItemHeader {
id: Rc::new(episode.id.to_string()),
uuid: Rc::new(generate_playlist_uuid(&input.name, &episode.id, PlaylistItemType::Series, &episode_url)),
name: Rc::new(series_name.to_string()),
logo: Rc::new(episode.info.as_ref().map_or_else(String::new, |info| info.movie_image.to_string())),
group: Rc::new(group_title.to_string()),
title: Rc::new(episode.title.clone()),
url: episode_url,
header: PlaylistItemHeader {
id: episode.id.to_string(),
uuid: generate_playlist_uuid(&input.name, &episode.id, PlaylistItemType::Series, &episode_url),
name: series_name.to_string(),
logo: episode.info.as_ref().map_or_else(String::new, |info| info.movie_image.to_string()),
group: group_title.to_string(),
title: episode.title.clone(),
url: episode_url.to_string(),
item_type: PlaylistItemType::Series,
xtream_cluster: XtreamCluster::Series,
additional_properties: episode.get_additional_properties(&series_info),
category_id: 0,
input_name: Rc::new(input.name.to_string()),
input_name: input.name.to_string(),
..Default::default()
})
}
})
}).collect();
return if result.is_empty() { Ok(None) } else { Ok(Some(result)) };
@@ -100,13 +98,13 @@ pub fn get_xtream_url(xtream_cluster: XtreamCluster, url: &str,
}
pub fn create_xtream_url(xtream_cluster: XtreamCluster, url: &str, username: &str, password: &str,
stream: &XtreamStream, live_stream_use_prefix: bool, live_stream_without_extension: bool) -> Rc<String> {
stream: &XtreamStream, live_stream_use_prefix: bool, live_stream_without_extension: bool) -> String {
if stream.direct_source.is_empty() {
Rc::new(get_xtream_url(xtream_cluster, url, username, password, stream.get_stream_id(),
get_xtream_url(xtream_cluster, url, username, password, stream.get_stream_id(),
stream.container_extension.as_ref().map(std::string::ToString::to_string).as_ref(),
live_stream_use_prefix, live_stream_without_extension))
live_stream_use_prefix, live_stream_without_extension)
} else {
Rc::clone(&stream.direct_source)
stream.direct_source.to_string()
}
}
@@ -116,65 +114,63 @@ pub fn parse_xtream(input: &ConfigInput,
streams: &Value) -> Result<Option<Vec<PlaylistGroup>>, M3uFilterError> {
match map_to_xtream_category(categories) {
Ok(xtream_categories) => {
let input_name = Rc::new(input.name.to_string());
let input_name = Arc::new(input.name.to_string());
let url = input.url.as_str();
let username = input.username.as_ref().map_or("", |v| v);
let password = input.password.as_ref().map_or("", |v| v);
match map_to_xtream_streams(xtream_cluster, streams) {
Ok(xtream_streams) => {
let mut group_map: HashMap::<Rc<String>, RefCell<XtreamCategory>> =
Ok(mut xtream_streams) => {
let mut group_map: HashMap::<String, XtreamCategory> =
xtream_categories.into_iter().map(|category|
(Rc::clone(&category.category_id), RefCell::new(category))
(category.category_id.to_string(), category)
).collect();
let unknown_grp = RefCell::new(XtreamCategory {
category_id: Rc::new("0".to_string()),
category_name: Rc::new("Unknown".to_string()),
let mut unknown_grp = XtreamCategory {
category_id: "0".to_string(),
category_name: "Unknown".to_string(),
channels: vec![],
});
};
let (live_stream_use_prefix, live_stream_without_extension) = input.options.as_ref()
.map_or((true, false), |o| (o.xtream_live_stream_use_prefix, o.xtream_live_stream_without_extension));
for stream in xtream_streams {
let group = group_map.get(&stream.category_id).unwrap_or(&unknown_grp);
let mut grp = group.borrow_mut();
let category_name = &grp.category_name;
let stream_url = create_xtream_url(xtream_cluster, url, username, password, &stream, live_stream_use_prefix, live_stream_without_extension);
for stream in &mut xtream_streams {
let group = group_map.get_mut(&stream.category_id).unwrap_or(&mut unknown_grp);
let category_name = &group.category_name;
let stream_url = create_xtream_url(xtream_cluster, url, username, password, stream, live_stream_use_prefix, live_stream_without_extension);
let item_type = PlaylistItemType::from(xtream_cluster);
let item = PlaylistItem {
header: RefCell::new(PlaylistItemHeader {
id: Rc::new(stream.get_stream_id().to_string()),
uuid: Rc::new(generate_playlist_uuid(&input_name, &stream.get_stream_id().to_string(), item_type, &stream_url)),
name: Rc::clone(&stream.name),
logo: Rc::clone(&stream.stream_icon),
group: Rc::clone(category_name),
title: Rc::clone(&stream.name),
url: stream_url,
header: PlaylistItemHeader {
id: stream.get_stream_id().to_string(),
uuid: generate_playlist_uuid(&input_name, &stream.get_stream_id().to_string(), item_type, &stream_url),
name: stream.name.to_string(),
logo: stream.stream_icon.to_string(),
group: category_name.to_string(),
title: stream.name.to_string(),
url: stream_url.to_string(),
epg_channel_id: stream.epg_channel_id.clone(),
item_type,
xtream_cluster,
additional_properties: stream.get_additional_properties(),
category_id: 0,
input_name: Rc::clone(&input_name),
input_name: input_name.to_string(),
..Default::default()
}),
},
};
grp.add(item);
group.add(item);
}
let has_channels = !unknown_grp.borrow().channels.is_empty();
let has_channels = !unknown_grp.channels.is_empty();
if has_channels {
group_map.insert(Rc::new("0".to_string()), unknown_grp);
group_map.insert("0".to_string(), unknown_grp);
}
Ok(Some(group_map.values().filter(|category| !category.borrow().channels.is_empty())
Ok(Some(group_map.values().filter(|category| !category.channels.is_empty())
.map(|category| {
let cat = category.borrow();
PlaylistGroup {
id: cat.category_id.parse::<u32>().unwrap_or(0),
id: category.category_id.parse::<u32>().unwrap_or(0),
xtream_cluster,
title: Rc::clone(&cat.category_name),
channels: cat.channels.clone(),
title: category.category_name.to_string(),
channels: category.channels.clone(),
}
}).collect()))
}