Dark-Alex-17/managarr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added collections support

Browse Source
This commit is contained in:
Dark-Alex-17
2023-08-08 10:50:04 -06:00
parent 43e35da49f
commit ff6e392af1
6 changed files with 565 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ui/radarr_ui.rs
+282 -8
View File
@@ -5,7 +5,7 @@ use chrono::{Duration, Utc};
use tui::backend::Backend;
use tui::layout::{Alignment, Constraint, Rect};
use tui::style::{Color, Style};
use tui::text::Text;
use tui::text::{Spans, Text};
use tui::widgets::{Block, Cell, Paragraph, Row, Wrap};
use tui::Frame;
@@ -14,26 +14,41 @@ use crate::app::{App, Route};
use crate::logos::RADARR_LOGO;
use crate::network::radarr_network::{Credit, DiskSpace, DownloadRecord, Movie, MovieHistoryItem};
use crate::ui::utils::{
horizontal_chunks, layout_block_top_border, line_gauge_with_label, line_gauge_with_title,
style_bold, style_failure, style_success, style_warning, title_block,
vertical_chunks_with_margin,
borderless_block, horizontal_chunks, layout_block_bottom_border, layout_block_top_border,
layout_block_top_border_with_title, layout_block_with_title, line_gauge_with_label,
line_gauge_with_title, spans_info_default, spans_info_primary, spans_info_with_style, style_bold,
style_default, style_default_bold, style_failure, style_primary, style_success, style_warning,
title_block, title_style, vertical_chunks, vertical_chunks_with_margin,
};
use crate::ui::{
draw_large_popup_over, draw_small_popup_over, draw_table, draw_tabs, loading, TableProps,
};
use crate::ui::{draw_large_popup_over, draw_table, draw_tabs, loading, TableProps};
use crate::utils::{convert_runtime, convert_to_gb};
pub(super) fn draw_radarr_ui<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect) {
let (content_rect, _) = draw_tabs(f, area, " Movies ", &app.data.radarr_data.main_tabs);
if let Route::Radarr(active_radarr_block) = app.get_current_route() {
if let Route::Radarr(active_radarr_block) = app.get_current_route().clone() {
match active_radarr_block {
ActiveRadarrBlock::Movies => draw_library(f, app, content_rect),
ActiveRadarrBlock::Downloads => draw_downloads(f, app, content_rect),
ActiveRadarrBlock::Collections => draw_collections(f, app, content_rect),
ActiveRadarrBlock::MovieDetails
| ActiveRadarrBlock::MovieHistory
| ActiveRadarrBlock::FileInfo
| ActiveRadarrBlock::Cast
| ActiveRadarrBlock::Crew => {
draw_large_popup_over(f, app, content_rect, draw_library, draw_movie_info)
}
ActiveRadarrBlock::CollectionDetails | ActiveRadarrBlock::ViewMovieOverview => {
draw_large_popup_over(
f,
app,
content_rect,
draw_collections,
draw_collection_details_popup,
)
}
_ => (),
}
}
@@ -189,12 +204,183 @@ fn draw_downloads<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect) {
Cell::from(indexer.to_owned()),
Cell::from(download_client.to_owned()),
])
.style(style_success())
.style(style_primary())
},
app.is_loading,
);
}
fn draw_collections<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect) {
let quality_profile_map = &app.data.radarr_data.quality_profile_map;
draw_table(
f,
area,
layout_block_top_border(),
TableProps {
content: &mut app.data.radarr_data.collections,
table_headers: vec![
"Collection",
"Search on Add?",
"Number of Movies",
"Root Folder Path",
"Quality Profile",
],
constraints: iter::repeat(Constraint::Ratio(1, 5)).take(5).collect(),
},
|collection| {
let number_of_movies = collection.movies.clone().unwrap_or_default().len();
Row::new(vec![
Cell::from(collection.title.to_owned()),
Cell::from(collection.search_on_add.to_string()),
Cell::from(number_of_movies.to_string()),
Cell::from(collection.root_folder_path.clone().unwrap_or_default()),
Cell::from(
quality_profile_map
.get(&collection.quality_profile_id.as_u64().unwrap())
.unwrap()
.to_owned(),
),
])
.style(style_primary())
},
app.is_loading,
);
}
fn draw_collection_details<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, content_area: Rect) {
let chunks = vertical_chunks_with_margin(
vec![Constraint::Length(10), Constraint::Min(0)],
content_area,
1,
);
let collection_selection = app.data.radarr_data.collections.current_selection();
let quality_profile = app
.data
.radarr_data
.quality_profile_map
.get(&collection_selection.quality_profile_id.as_u64().unwrap())
.unwrap()
.to_owned();
let collection_description = Text::from(vec![
spans_info_primary(
"Overview: ".to_owned(),
collection_selection.overview.clone().unwrap_or_default(),
),
spans_info_primary(
"Root Folder Path: ".to_owned(),
collection_selection
.root_folder_path
.clone()
.unwrap_or_default(),
),
spans_info_primary(
"Search on Add: ".to_owned(),
collection_selection.search_on_add.to_string(),
),
spans_info_primary("Quality Profile: ".to_owned(), quality_profile),
]);
let description_paragraph = Paragraph::new(collection_description)
.block(borderless_block())
.wrap(Wrap { trim: false });
f.render_widget(
layout_block_with_title(title_style(&collection_selection.title)),
content_area,
);
f.render_widget(description_paragraph, chunks[0]);
draw_table(
f,
chunks[1],
layout_block_top_border_with_title(title_style("Movies")),
TableProps {
content: &mut app.data.radarr_data.collection_movies,
table_headers: vec![
"Title",
"Year",
"Runtime",
"IMDB Rating",
"Rotten Tomatoes Rating",
"Genres",
],
constraints: vec![
Constraint::Percentage(20),
Constraint::Percentage(8),
Constraint::Percentage(10),
Constraint::Percentage(10),
Constraint::Percentage(18),
Constraint::Percentage(30),
],
},
|movie| {
let (hours, minutes) = convert_runtime(movie.runtime.as_u64().unwrap());
let imdb_rating = movie
.ratings
.imdb
.clone()
.unwrap_or_default()
.value
.as_f64()
.unwrap();
let rotten_tomatoes_rating = movie
.ratings
.rotten_tomatoes
.clone()
.unwrap_or_default()
.value
.as_u64()
.unwrap();
let imdb_rating = if imdb_rating == 0.0 {
String::default()
} else {
format!("{:.1}", imdb_rating)
};
let rotten_tomatoes_rating = if rotten_tomatoes_rating == 0 {
String::default()
} else {
format!("{}%", rotten_tomatoes_rating)
};
Row::new(vec![
Cell::from(movie.title.to_owned()),
Cell::from(movie.year.as_u64().unwrap().to_string()),
Cell::from(format!("{}h {}m", hours, minutes)),
Cell::from(imdb_rating),
Cell::from(rotten_tomatoes_rating),
Cell::from(movie.genres.join(", ")),
])
.style(style_primary())
},
app.is_loading,
);
}
fn draw_collection_details_popup<B: Backend>(
f: &mut Frame<'_, B>,
app: &mut App,
content_area: Rect,
) {
if let Route::Radarr(active_radarr_block) = app.get_current_route() {
match active_radarr_block {
ActiveRadarrBlock::ViewMovieOverview => {
draw_small_popup_over(
f,
app,
content_area,
draw_collection_details,
draw_movie_overview,
);
}
ActiveRadarrBlock::CollectionDetails => draw_collection_details(f, app, content_area),
_ => (),
}
}
}
fn draw_movie_info<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect) {
let (content_area, block) =
draw_tabs(f, area, "Movie Info", &app.data.radarr_data.movie_info_tabs);
@@ -203,6 +389,7 @@ fn draw_movie_info<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect)
app.data.radarr_data.movie_info_tabs.get_active_route()
{
match active_radarr_block {
ActiveRadarrBlock::FileInfo => draw_file_info(f, app, content_area, block),
ActiveRadarrBlock::MovieDetails => draw_movie_details(f, app, content_area, block),
ActiveRadarrBlock::MovieHistory => draw_movie_history(f, app, content_area, block),
ActiveRadarrBlock::Cast => draw_movie_cast(f, app, content_area, block),
@@ -212,6 +399,24 @@ fn draw_movie_info<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect)
}
}
fn draw_movie_overview<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, content_area: Rect) {
let mut overview = Text::from(
app
.data
.radarr_data
.collection_movies
.current_selection_clone()
.overview,
);
overview.patch_style(style_default());
let paragraph = Paragraph::new(overview)
.block(layout_block_with_title(title_style("Overview")))
.wrap(Wrap { trim: false });
f.render_widget(paragraph, content_area);
}
fn draw_movie_details<B: Backend>(
f: &mut Frame<'_, B>,
app: &App,
@@ -231,7 +436,21 @@ fn draw_movie_details<B: Backend>(
.unwrap()
.split(": ")
.collect::<Vec<&str>>()[1];
let mut text = Text::from(movie_details);
let mut text = Text::from(
app
.data
.radarr_data
.movie_details
.items
.iter()
.map(|line| {
let split = line.split(':').collect::<Vec<&str>>();
let title = format!("{}:", split[0]);
spans_info_default(title, split[1].to_owned())
})
.collect::<Vec<Spans>>(),
);
text.patch_style(determine_style_from_download_status(download_status));
let paragraph = Paragraph::new(text)
@@ -245,6 +464,61 @@ fn draw_movie_details<B: Backend>(
}
}
fn draw_file_info<B: Backend>(f: &mut Frame<'_, B>, app: &App, content_area: Rect, block: Block) {
let file_info = app.data.radarr_data.file_details.to_owned();
if !file_info.is_empty() {
let audio_details = app.data.radarr_data.audio_details.to_owned();
let video_details = app.data.radarr_data.video_details.to_owned();
let chunks = vertical_chunks(
vec![
Constraint::Length(1),
Constraint::Length(5),
Constraint::Length(1),
Constraint::Length(6),
Constraint::Length(1),
Constraint::Length(7),
],
content_area,
);
let mut file_details_title = Text::from("File Details");
let mut audio_details_title = Text::from("Audio Details");
let mut video_details_title = Text::from("Video Details");
file_details_title.patch_style(style_bold());
audio_details_title.patch_style(style_bold());
video_details_title.patch_style(style_bold());
let file_details_title_paragraph = Paragraph::new(file_details_title).block(borderless_block());
let audio_details_title_paragraph =
Paragraph::new(audio_details_title).block(borderless_block());
let video_details_title_paragraph =
Paragraph::new(video_details_title).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, chunks[0]);
f.render_widget(file_details_paragraph, chunks[1]);
f.render_widget(audio_details_title_paragraph, chunks[2]);
f.render_widget(audio_details_paragraph, chunks[3]);
f.render_widget(video_details_title_paragraph, chunks[4]);
f.render_widget(video_details_paragraph, chunks[5]);
} else {
loading(f, block, content_area, app.is_loading);
}
}
fn draw_movie_history<B: Backend>(
f: &mut Frame<'_, B>,
app: &mut App,
src/ui/utils.rs
+33
View File
@@ -66,6 +66,39 @@ pub fn layout_block_top_border<'a>() -> Block<'a> {
Block::default().borders(Borders::TOP)
}
pub fn layout_block_bottom_border<'a>() -> Block<'a> {
Block::default().borders(Borders::BOTTOM)
}
pub fn borderless_block<'a>() -> Block<'a> {
Block::default()
}
pub fn spans_info_with_style<'a>(
title: String,
content: String,
title_style: Style,
content_style: Style,
) -> Spans<'a> {
Spans::from(vec![
Span::styled(title, title_style),
Span::styled(content, content_style),
])
}
pub fn spans_info_default<'a>(title: String, content: String) -> Spans<'a> {
spans_info_with_style(title, content, style_bold(), style_default())
}
pub fn spans_info_primary<'a>(title: String, content: String) -> Spans<'a> {
spans_info_with_style(
title,
content,
style_primary().add_modifier(Modifier::BOLD),
style_default(),
)
}
pub fn style_bold() -> Style {
Style::default().add_modifier(Modifier::BOLD)
}