614 lines
18 KiB
Rust
614 lines
18 KiB
Rust
use std::iter;
|
|
|
|
use ratatui::layout::{Alignment, Constraint, Layout, Rect};
|
|
use ratatui::style::{Style, Stylize};
|
|
use ratatui::text::{Line, Span, Text};
|
|
use ratatui::widgets::{Cell, ListItem, Paragraph, Row, Wrap};
|
|
use ratatui::Frame;
|
|
|
|
use crate::app::App;
|
|
use crate::models::radarr_models::{Credit, MovieHistoryItem, Release, ReleaseField};
|
|
use crate::models::servarr_data::radarr::radarr_data::{ActiveRadarrBlock, MOVIE_DETAILS_BLOCKS};
|
|
use crate::models::Route;
|
|
use crate::ui::radarr_ui::library::draw_library;
|
|
use crate::ui::styles::ManagarrStyle;
|
|
use crate::ui::utils::{
|
|
borderless_block, get_width_from_percentage, layout_block_bottom_border, layout_block_top_border,
|
|
};
|
|
use crate::ui::{
|
|
draw_drop_down_popup, draw_large_popup_over, draw_prompt_box, draw_prompt_box_with_content,
|
|
draw_prompt_popup_over, draw_selectable_list, draw_small_popup_over, draw_table, draw_tabs,
|
|
loading, DrawUi, TableProps,
|
|
};
|
|
use crate::utils::convert_to_gb;
|
|
|
|
#[cfg(test)]
|
|
#[path = "movie_details_ui_tests.rs"]
|
|
mod movie_details_ui_tests;
|
|
|
|
pub(super) struct MovieDetailsUi;
|
|
|
|
impl DrawUi for MovieDetailsUi {
|
|
fn accepts(route: Route) -> bool {
|
|
if let Route::Radarr(active_radarr_block, _) = route {
|
|
return MOVIE_DETAILS_BLOCKS.contains(&active_radarr_block);
|
|
}
|
|
|
|
false
|
|
}
|
|
|
|
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
if let Route::Radarr(active_radarr_block, context_option) = *app.get_current_route() {
|
|
let draw_movie_info_popup = |f: &mut Frame<'_>, app: &mut App<'_>, popup_area: Rect| {
|
|
let content_area = draw_tabs(
|
|
f,
|
|
popup_area,
|
|
"Movie Info",
|
|
&app.data.radarr_data.movie_info_tabs,
|
|
);
|
|
|
|
match context_option.unwrap_or(active_radarr_block) {
|
|
ActiveRadarrBlock::AutomaticallySearchMoviePrompt => draw_prompt_popup_over(
|
|
f,
|
|
app,
|
|
content_area,
|
|
draw_movie_info,
|
|
draw_search_movie_prompt,
|
|
),
|
|
ActiveRadarrBlock::UpdateAndScanPrompt => draw_prompt_popup_over(
|
|
f,
|
|
app,
|
|
content_area,
|
|
draw_movie_info,
|
|
draw_update_and_scan_prompt,
|
|
),
|
|
ActiveRadarrBlock::ManualSearchSortPrompt => draw_drop_down_popup(
|
|
f,
|
|
app,
|
|
content_area,
|
|
draw_movie_info,
|
|
|f, app, content_area| {
|
|
draw_selectable_list(
|
|
f,
|
|
content_area,
|
|
&mut app
|
|
.data
|
|
.radarr_data
|
|
.movie_details_modal
|
|
.as_mut()
|
|
.unwrap()
|
|
.movie_releases_sort,
|
|
|sort_option| ListItem::new(sort_option.to_string()),
|
|
)
|
|
},
|
|
),
|
|
ActiveRadarrBlock::ManualSearchConfirmPrompt => draw_small_popup_over(
|
|
f,
|
|
app,
|
|
content_area,
|
|
draw_movie_info,
|
|
draw_manual_search_confirm_prompt,
|
|
),
|
|
_ => draw_movie_info(f, app, content_area),
|
|
}
|
|
};
|
|
|
|
draw_large_popup_over(f, app, area, draw_library, draw_movie_info_popup);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn draw_movie_info(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
if let Route::Radarr(active_radarr_block, _) =
|
|
app.data.radarr_data.movie_info_tabs.get_active_route()
|
|
{
|
|
match active_radarr_block {
|
|
ActiveRadarrBlock::FileInfo => draw_file_info(f, app, area),
|
|
ActiveRadarrBlock::MovieDetails => draw_movie_details(f, app, area),
|
|
ActiveRadarrBlock::MovieHistory => draw_movie_history(f, app, area),
|
|
ActiveRadarrBlock::Cast => draw_movie_cast(f, app, area),
|
|
ActiveRadarrBlock::Crew => draw_movie_crew(f, app, area),
|
|
ActiveRadarrBlock::ManualSearch => draw_movie_releases(f, app, area),
|
|
_ => (),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn draw_search_movie_prompt(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
draw_prompt_box(
|
|
f,
|
|
area,
|
|
"Automatic Movie Search",
|
|
format!(
|
|
"Do you want to trigger an automatic search of your indexers for the movie: {}?",
|
|
app.data.radarr_data.movies.current_selection().title
|
|
)
|
|
.as_str(),
|
|
app.data.radarr_data.prompt_confirm,
|
|
);
|
|
}
|
|
|
|
fn draw_update_and_scan_prompt(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
draw_prompt_box(
|
|
f,
|
|
area,
|
|
"Update and Scan",
|
|
format!(
|
|
"Do you want to trigger an update and disk scan for the movie: {}?",
|
|
app.data.radarr_data.movies.current_selection().title
|
|
)
|
|
.as_str(),
|
|
app.data.radarr_data.prompt_confirm,
|
|
);
|
|
}
|
|
|
|
fn draw_file_info(f: &mut Frame<'_>, app: &App<'_>, area: Rect) {
|
|
match app.data.radarr_data.movie_details_modal.as_ref() {
|
|
Some(movie_details_modal)
|
|
if !movie_details_modal.file_details.is_empty() && !app.is_loading =>
|
|
{
|
|
let file_info = movie_details_modal.file_details.to_owned();
|
|
let audio_details = movie_details_modal.audio_details.to_owned();
|
|
let video_details = movie_details_modal.video_details.to_owned();
|
|
let [file_details_title_area, file_details_area, audio_details_title_area, audio_details_area, video_details_title_area, video_details_area] =
|
|
Layout::vertical([
|
|
Constraint::Length(2),
|
|
Constraint::Length(5),
|
|
Constraint::Length(1),
|
|
Constraint::Length(6),
|
|
Constraint::Length(1),
|
|
Constraint::Length(7),
|
|
])
|
|
.areas(area);
|
|
|
|
let file_details_title_paragraph =
|
|
Paragraph::new("File Details".bold()).block(layout_block_top_border());
|
|
let audio_details_title_paragraph =
|
|
Paragraph::new("Audio Details".bold()).block(borderless_block());
|
|
let video_details_title_paragraph =
|
|
Paragraph::new("Video Details".bold()).block(borderless_block());
|
|
|
|
let file_details = Text::from(file_info);
|
|
let audio_details = Text::from(audio_details);
|
|
let video_details = Text::from(video_details);
|
|
|
|
let file_details_paragraph = Paragraph::new(file_details)
|
|
.block(layout_block_bottom_border())
|
|
.wrap(Wrap { trim: false });
|
|
let audio_details_paragraph = Paragraph::new(audio_details)
|
|
.block(layout_block_bottom_border())
|
|
.wrap(Wrap { trim: false });
|
|
let video_details_paragraph = Paragraph::new(video_details)
|
|
.block(borderless_block())
|
|
.wrap(Wrap { trim: false });
|
|
|
|
f.render_widget(file_details_title_paragraph, file_details_title_area);
|
|
f.render_widget(file_details_paragraph, file_details_area);
|
|
f.render_widget(audio_details_title_paragraph, audio_details_title_area);
|
|
f.render_widget(audio_details_paragraph, audio_details_area);
|
|
f.render_widget(video_details_title_paragraph, video_details_title_area);
|
|
f.render_widget(video_details_paragraph, video_details_area);
|
|
}
|
|
_ => loading(f, layout_block_top_border(), area, app.is_loading),
|
|
}
|
|
}
|
|
|
|
fn draw_movie_details(f: &mut Frame<'_>, app: &App<'_>, area: Rect) {
|
|
let block = layout_block_top_border();
|
|
|
|
match app.data.radarr_data.movie_details_modal.as_ref() {
|
|
Some(movie_details_modal) if !app.is_loading => {
|
|
let movie_details = &movie_details_modal.movie_details;
|
|
let download_status = movie_details
|
|
.items
|
|
.iter()
|
|
.find(|&line| line.starts_with("Status: "))
|
|
.unwrap()
|
|
.split(": ")
|
|
.collect::<Vec<&str>>()[1];
|
|
let text = Text::from(
|
|
movie_details
|
|
.items
|
|
.iter()
|
|
.map(|line| {
|
|
let split = line.split(':').collect::<Vec<&str>>();
|
|
let title = format!("{}:", split[0]);
|
|
let style = style_from_download_status(download_status);
|
|
|
|
Line::from(vec![
|
|
title.bold().style(style),
|
|
Span::styled(split[1..].join(":"), style),
|
|
])
|
|
})
|
|
.collect::<Vec<Line<'_>>>(),
|
|
);
|
|
|
|
let paragraph = Paragraph::new(text)
|
|
.block(block)
|
|
.wrap(Wrap { trim: false })
|
|
.scroll((movie_details.offset, 0));
|
|
|
|
f.render_widget(paragraph, area);
|
|
}
|
|
_ => loading(
|
|
f,
|
|
block,
|
|
area,
|
|
app.is_loading || app.data.radarr_data.movie_details_modal.is_none(),
|
|
),
|
|
}
|
|
}
|
|
|
|
fn draw_movie_history(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
if let Some(movie_details_modal) = app.data.radarr_data.movie_details_modal.as_mut() {
|
|
let current_selection = if movie_details_modal.movie_history.items.is_empty() {
|
|
MovieHistoryItem::default()
|
|
} else {
|
|
movie_details_modal
|
|
.movie_history
|
|
.current_selection()
|
|
.clone()
|
|
};
|
|
|
|
draw_table(
|
|
f,
|
|
area,
|
|
layout_block_top_border(),
|
|
TableProps {
|
|
content: Some(&mut movie_details_modal.movie_history),
|
|
wrapped_content: None,
|
|
table_headers: vec!["Source Title", "Event Type", "Languages", "Quality", "Date"],
|
|
constraints: vec![
|
|
Constraint::Percentage(34),
|
|
Constraint::Percentage(17),
|
|
Constraint::Percentage(14),
|
|
Constraint::Percentage(14),
|
|
Constraint::Percentage(21),
|
|
],
|
|
help: app
|
|
.data
|
|
.radarr_data
|
|
.movie_info_tabs
|
|
.get_active_tab_contextual_help(),
|
|
},
|
|
|movie_history_item| {
|
|
let MovieHistoryItem {
|
|
source_title,
|
|
quality,
|
|
languages,
|
|
date,
|
|
event_type,
|
|
} = movie_history_item;
|
|
|
|
movie_history_item.source_title.scroll_left_or_reset(
|
|
get_width_from_percentage(area, 34),
|
|
current_selection == *movie_history_item,
|
|
app.tick_count % app.ticks_until_scroll == 0,
|
|
);
|
|
|
|
Row::new(vec![
|
|
Cell::from(source_title.to_string()),
|
|
Cell::from(event_type.to_owned()),
|
|
Cell::from(
|
|
languages
|
|
.iter()
|
|
.map(|language| language.name.to_owned())
|
|
.collect::<Vec<String>>()
|
|
.join(","),
|
|
),
|
|
Cell::from(quality.quality.name.to_owned()),
|
|
Cell::from(date.to_string()),
|
|
])
|
|
.success()
|
|
},
|
|
app.is_loading,
|
|
true,
|
|
);
|
|
}
|
|
}
|
|
|
|
fn draw_movie_cast(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
draw_table(
|
|
f,
|
|
area,
|
|
layout_block_top_border(),
|
|
TableProps {
|
|
content: Some(
|
|
&mut app
|
|
.data
|
|
.radarr_data
|
|
.movie_details_modal
|
|
.as_mut()
|
|
.unwrap()
|
|
.movie_cast,
|
|
),
|
|
wrapped_content: None,
|
|
constraints: iter::repeat(Constraint::Ratio(1, 2)).take(2).collect(),
|
|
table_headers: vec!["Cast Member", "Character"],
|
|
help: app
|
|
.data
|
|
.radarr_data
|
|
.movie_info_tabs
|
|
.get_active_tab_contextual_help(),
|
|
},
|
|
|cast_member| {
|
|
let Credit {
|
|
person_name,
|
|
character,
|
|
..
|
|
} = cast_member;
|
|
|
|
Row::new(vec![
|
|
Cell::from(person_name.to_owned()),
|
|
Cell::from(character.clone().unwrap_or_default()),
|
|
])
|
|
.success()
|
|
},
|
|
app.is_loading,
|
|
true,
|
|
);
|
|
}
|
|
|
|
fn draw_movie_crew(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
draw_table(
|
|
f,
|
|
area,
|
|
layout_block_top_border(),
|
|
TableProps {
|
|
content: Some(
|
|
&mut app
|
|
.data
|
|
.radarr_data
|
|
.movie_details_modal
|
|
.as_mut()
|
|
.unwrap()
|
|
.movie_crew,
|
|
),
|
|
wrapped_content: None,
|
|
constraints: iter::repeat(Constraint::Ratio(1, 3)).take(3).collect(),
|
|
table_headers: vec!["Crew Member", "Job", "Department"],
|
|
help: app
|
|
.data
|
|
.radarr_data
|
|
.movie_info_tabs
|
|
.get_active_tab_contextual_help(),
|
|
},
|
|
|crew_member| {
|
|
let Credit {
|
|
person_name,
|
|
job,
|
|
department,
|
|
..
|
|
} = crew_member;
|
|
|
|
Row::new(vec![
|
|
Cell::from(person_name.to_owned()),
|
|
Cell::from(job.clone().unwrap_or_default()),
|
|
Cell::from(department.clone().unwrap_or_default()),
|
|
])
|
|
.success()
|
|
},
|
|
app.is_loading,
|
|
true,
|
|
);
|
|
}
|
|
|
|
fn draw_movie_releases(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
let (current_selection, is_empty, sort_ascending) =
|
|
match app.data.radarr_data.movie_details_modal.as_ref() {
|
|
Some(movie_details_modal) if !movie_details_modal.movie_releases.items.is_empty() => (
|
|
movie_details_modal
|
|
.movie_releases
|
|
.current_selection()
|
|
.clone(),
|
|
movie_details_modal.movie_releases.items.is_empty(),
|
|
movie_details_modal.sort_ascending,
|
|
),
|
|
_ => (Release::default(), true, None),
|
|
};
|
|
let current_route = *app.get_current_route();
|
|
let mut table_headers_vec = vec![
|
|
"Source".to_owned(),
|
|
"Age".to_owned(),
|
|
"⛔".to_owned(),
|
|
"Title".to_owned(),
|
|
"Indexer".to_owned(),
|
|
"Size".to_owned(),
|
|
"Peers".to_owned(),
|
|
"Language".to_owned(),
|
|
"Quality".to_owned(),
|
|
];
|
|
|
|
if let Some(ascending) = sort_ascending {
|
|
let direction = if ascending { " ▲" } else { " ▼" };
|
|
|
|
match app
|
|
.data
|
|
.radarr_data
|
|
.movie_details_modal
|
|
.as_ref()
|
|
.unwrap()
|
|
.movie_releases_sort
|
|
.current_selection()
|
|
{
|
|
ReleaseField::Source => table_headers_vec[0].push_str(direction),
|
|
ReleaseField::Age => table_headers_vec[1].push_str(direction),
|
|
ReleaseField::Rejected => table_headers_vec[2].push_str(direction),
|
|
ReleaseField::Title => table_headers_vec[3].push_str(direction),
|
|
ReleaseField::Indexer => table_headers_vec[4].push_str(direction),
|
|
ReleaseField::Size => table_headers_vec[5].push_str(direction),
|
|
ReleaseField::Peers => table_headers_vec[6].push_str(direction),
|
|
ReleaseField::Language => table_headers_vec[7].push_str(direction),
|
|
ReleaseField::Quality => table_headers_vec[8].push_str(direction),
|
|
}
|
|
}
|
|
|
|
draw_table(
|
|
f,
|
|
area,
|
|
layout_block_top_border(),
|
|
TableProps {
|
|
content: Some(
|
|
&mut app
|
|
.data
|
|
.radarr_data
|
|
.movie_details_modal
|
|
.as_mut()
|
|
.unwrap()
|
|
.movie_releases,
|
|
),
|
|
wrapped_content: None,
|
|
constraints: vec![
|
|
Constraint::Length(9),
|
|
Constraint::Length(10),
|
|
Constraint::Length(5),
|
|
Constraint::Percentage(30),
|
|
Constraint::Percentage(18),
|
|
Constraint::Length(12),
|
|
Constraint::Length(12),
|
|
Constraint::Percentage(7),
|
|
Constraint::Percentage(10),
|
|
],
|
|
table_headers: table_headers_vec.iter().map(|s| &**s).collect(),
|
|
help: app
|
|
.data
|
|
.radarr_data
|
|
.movie_info_tabs
|
|
.get_active_tab_contextual_help(),
|
|
},
|
|
|release| {
|
|
let Release {
|
|
protocol,
|
|
age,
|
|
title,
|
|
indexer,
|
|
size,
|
|
rejected,
|
|
seeders,
|
|
leechers,
|
|
languages,
|
|
quality,
|
|
..
|
|
} = release;
|
|
let age = format!("{age} days");
|
|
title.scroll_left_or_reset(
|
|
get_width_from_percentage(area, 30),
|
|
current_selection == *release
|
|
&& current_route != ActiveRadarrBlock::ManualSearchConfirmPrompt.into(),
|
|
app.tick_count % app.ticks_until_scroll == 0,
|
|
);
|
|
let size = convert_to_gb(*size);
|
|
let rejected_str = if *rejected { "⛔" } else { "" };
|
|
let peers = if seeders.is_none() || leechers.is_none() {
|
|
Text::from("")
|
|
} else {
|
|
let seeders = seeders.clone().unwrap().as_u64().unwrap();
|
|
let leechers = leechers.clone().unwrap().as_u64().unwrap();
|
|
|
|
decorate_peer_style(
|
|
seeders,
|
|
leechers,
|
|
Text::from(format!("{seeders} / {leechers}")),
|
|
)
|
|
};
|
|
|
|
let language = if languages.is_some() {
|
|
languages.clone().unwrap()[0].name.clone()
|
|
} else {
|
|
String::new()
|
|
};
|
|
let quality = quality.quality.name.clone();
|
|
|
|
Row::new(vec![
|
|
Cell::from(protocol.clone()),
|
|
Cell::from(age),
|
|
Cell::from(rejected_str),
|
|
Cell::from(title.to_string()),
|
|
Cell::from(indexer.clone()),
|
|
Cell::from(format!("{size:.1} GB")),
|
|
Cell::from(peers),
|
|
Cell::from(language),
|
|
Cell::from(quality),
|
|
])
|
|
.primary()
|
|
},
|
|
app.is_loading || is_empty,
|
|
true,
|
|
);
|
|
}
|
|
|
|
fn draw_manual_search_confirm_prompt(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
let current_selection = app
|
|
.data
|
|
.radarr_data
|
|
.movie_details_modal
|
|
.as_ref()
|
|
.unwrap()
|
|
.movie_releases
|
|
.current_selection();
|
|
let title = if current_selection.rejected {
|
|
"Download Rejected Release"
|
|
} else {
|
|
"Download Release"
|
|
};
|
|
let prompt = if current_selection.rejected {
|
|
format!(
|
|
"Do you really want to download the rejected release: {}?",
|
|
¤t_selection.title.text
|
|
)
|
|
} else {
|
|
format!(
|
|
"Do you want to download the release: {}?",
|
|
¤t_selection.title.text
|
|
)
|
|
};
|
|
|
|
if current_selection.rejected {
|
|
let mut lines_vec = vec![Line::from("Rejection reasons: ".primary().bold())];
|
|
let mut rejections_spans = current_selection
|
|
.rejections
|
|
.clone()
|
|
.unwrap_or_default()
|
|
.iter()
|
|
.map(|item| Line::from(format!("• {item}").primary().bold()))
|
|
.collect::<Vec<Line<'_>>>();
|
|
lines_vec.append(&mut rejections_spans);
|
|
|
|
let content_paragraph = Paragraph::new(lines_vec)
|
|
.block(borderless_block())
|
|
.wrap(Wrap { trim: false })
|
|
.alignment(Alignment::Left);
|
|
|
|
draw_prompt_box_with_content(
|
|
f,
|
|
area,
|
|
title,
|
|
&prompt,
|
|
Some(content_paragraph),
|
|
app.data.radarr_data.prompt_confirm,
|
|
);
|
|
} else {
|
|
draw_prompt_box(f, area, title, &prompt, app.data.radarr_data.prompt_confirm);
|
|
}
|
|
}
|
|
|
|
fn style_from_download_status(download_status: &str) -> Style {
|
|
match download_status {
|
|
"Downloaded" => Style::new().success(),
|
|
"Awaiting Import" => Style::new().awaiting_import(),
|
|
"Downloading" => Style::new().warning(),
|
|
"Missing" => Style::new().failure(),
|
|
_ => Style::new().success(),
|
|
}
|
|
}
|
|
|
|
fn decorate_peer_style(seeders: u64, leechers: u64, text: Text<'_>) -> Text<'_> {
|
|
if seeders == 0 {
|
|
text.failure()
|
|
} else if seeders < leechers {
|
|
text.warning()
|
|
} else {
|
|
text.success()
|
|
}
|
|
}
|