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

- Fix for telegram send error

Browse Source 
- Fix for series strm generation
- Input disabled is now disabled and can't be forced through cli to be enabled
This commit is contained in:
euzu
2026-01-02 13:18:08 +01:00
parent 4def0991cd
commit df2a4e4a72
8 changed files with 179 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/src/processing/processor/playlist.rs
+3 -6
View File
@@ -234,13 +234,10 @@ fn map_playlist_counter(target: &ConfigTarget, playlist: &mut [PlaylistGroup]) {
}
}
// If no input is enabled but the user set the target as command line argument,
// we force the input to be enabled.
// If there are enabled input, then only these are used.
// Inputs disabled in the config are always disabled.
// Command-line targets can only restrict enabled inputs, never enable them.
fn is_input_enabled(input: &ConfigInput, user_targets: &ProcessTargets) -> bool {
let input_enabled = input.enabled;
let input_id = input.id;
(!user_targets.enabled && input_enabled) || user_targets.has_input(input_id)
input.enabled && (!user_targets.enabled || user_targets.has_input(input.id))
}
fn is_target_enabled(target: &ConfigTarget, user_targets: &ProcessTargets) -> bool {
backend/src/processing/processor/xtream_series.rs
+56 -38
View File
@@ -1,9 +1,9 @@
use crate::model::FetchedPlaylist;
use crate::model::{AppConfig, ConfigTarget};
use crate::processing::parser::xtream::parse_xtream_series_info;
use crate::processing::processor::create_resolve_options_function_for_xtream_target;
use crate::processing::processor::playlist::ProcessingPipe;
use crate::processing::processor::xtream::playlist_resolve_download_playlist_item;
use crate::processing::processor::create_resolve_options_function_for_xtream_target;
use crate::repository::storage::get_input_storage_path;
use crate::repository::xtream_repository::persists_input_series_info;
use log::{error, info, log_enabled, Level};
@@ -15,8 +15,11 @@ use std::time::Instant;
create_resolve_options_function_for_xtream_target!(series);
async fn playlist_resolve_series_info(app_config: &Arc<AppConfig>, client: &reqwest::Client, errors: &mut Vec<TuliproxError>,
fpl: &mut FetchedPlaylist<'_>, resolve_delay: u16) -> Vec<PlaylistGroup> {
async fn playlist_resolve_series_info(app_config: &Arc<AppConfig>, client: &reqwest::Client,
errors: &mut Vec<TuliproxError>,
fpl: &mut FetchedPlaylist<'_>,
resolve_series: bool,
resolve_delay: u16) -> Vec<PlaylistGroup> {
let input = fpl.input;
let working_dir = &app_config.config.load().working_dir;
let storage_path = match get_input_storage_path(&input.name, working_dir) {
@@ -27,56 +30,69 @@ async fn playlist_resolve_series_info(app_config: &Arc<AppConfig>, client: &reqw
}
};
let series_info_count = fpl.playlist_groups.iter()
.flat_map(|plg| &plg.channels)
.filter(|&pli| pli.header.xtream_cluster == XtreamCluster::Series
&& pli.header.item_type == PlaylistItemType::SeriesInfo
&& !pli.has_details()).count();
let series_info_count = if resolve_series {
let count = fpl.playlist_groups.iter()
.flat_map(|plg| &plg.channels)
.filter(|&pli| pli.header.xtream_cluster == XtreamCluster::Series
&& pli.header.item_type == PlaylistItemType::SeriesInfo
&& !pli.has_details()).count();
info!("Found {count} series info to resolve");
count
} else {
0
};
info!("Found {series_info_count} series info to resolve");
let mut last_log_time = Instant::now();
let mut processed_series_info_count = 0;
let input = fpl.input;
let mut result: Vec<PlaylistGroup> = vec![];
for plg in &mut fpl.playlist_groups {
let mut group_series = vec![];
for pli in &mut plg.channels {
if pli.header.xtream_cluster != XtreamCluster::Series
|| pli.header.item_type != PlaylistItemType::SeriesInfo
|| pli.has_details() {
|| pli.header.item_type != PlaylistItemType::SeriesInfo {
continue;
}
let Some(provider_id) = pli.get_provider_id() else { continue; };
processed_series_info_count += 1;
let (group, series_name) = {
let header = &pli.header;
(header.group.clone(), if header.name.is_empty() { header.title.clone() } else { header.name.clone() })
};
if provider_id != 0 {
if provider_id == 0 {
continue;
}
let should_download = resolve_series && !pli.has_details();
if should_download {
processed_series_info_count += 1;
if let Some(content) = playlist_resolve_download_playlist_item(client, pli, fpl.input, errors, resolve_delay, XtreamCluster::Series).await {
if content.is_empty() { continue; }
match serde_json::from_str::<XtreamSeriesInfo>(&content) {
Ok(info) => {
let series_stream_props = SeriesStreamProperties::from_info(&info, pli);
// the input db needs to be updated
let _ = persists_input_series_info(app_config, &storage_path, pli.header.xtream_cluster, &input.name, provider_id, &series_stream_props).await;
// extract episodes from info
if let Some(episodes) = parse_xtream_series_info(&pli.get_uuid(), &series_stream_props, &group, &series_name, input) {
group_series.extend(episodes.into_iter());
if !content.is_empty() {
match serde_json::from_str::<XtreamSeriesInfo>(&content) {
Ok(info) => {
let series_stream_props = SeriesStreamProperties::from_info(&info, pli);
// the input db needs to be updated
let _ = persists_input_series_info(app_config, &storage_path, pli.header.xtream_cluster, &input.name, provider_id, &series_stream_props).await;
// Update in-memory playlist items with the newly fetched vod info.
// This makes the data available for later processing steps like STRM export.
pli.header.additional_properties = Some(StreamProperties::Series(Box::new(series_stream_props)));
}
Err(err) => {
error!("Failed to parse series info for provider_id {provider_id}: {err}");
}
// Update in-memory playlist items with the newly fetched vod info.
// This makes the data available for later processing steps like STRM export.
pli.header.additional_properties = Some(StreamProperties::Series(Box::new(series_stream_props)));
}
Err(err) => {
error!("Failed to parse series info for provider_id {provider_id}: {err}");
}
}
}
}
if log_enabled!(Level::Info)
&& last_log_time.elapsed().as_secs() >= 30 {
// extract episodes from info
if let Some(StreamProperties::Series(properties)) = pli.header.additional_properties.as_ref() {
let (group, series_name) = {
let header = &pli.header;
(header.group.clone(), if header.name.is_empty() { header.title.clone() } else { header.name.clone() })
};
if let Some(episodes) = parse_xtream_series_info(&pli.get_uuid(), properties, &group, &series_name, input) {
group_series.extend(episodes.into_iter());
}
}
if resolve_series && log_enabled!(Level::Info) && last_log_time.elapsed().as_secs() >= 30 {
info!("resolved {processed_series_info_count}/{series_info_count} series info");
last_log_time = Instant::now();
}
@@ -90,7 +106,9 @@ async fn playlist_resolve_series_info(app_config: &Arc<AppConfig>, client: &reqw
});
}
}
info!("resolved {processed_series_info_count}/{series_info_count} series info");
if resolve_series {
info!("resolved {processed_series_info_count}/{series_info_count} series info");
}
result
}
@@ -103,8 +121,8 @@ pub async fn playlist_resolve_series(cfg: &Arc<AppConfig>,
processed_fpl: &mut FetchedPlaylist<'_>,
) {
let (resolve_series, resolve_delay) = get_resolve_series_options(target, processed_fpl);
if !resolve_series { return; }
let series_playlist = playlist_resolve_series_info(cfg, client, errors, processed_fpl, resolve_delay).await;
let series_playlist = playlist_resolve_series_info(cfg, client, errors, processed_fpl, resolve_series, resolve_delay).await;
if series_playlist.is_empty() { return; }
// original content saved into original list