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

Implemented full system browsing support with logs, events, and tasks.

Browse Source
This commit is contained in:
Dark-Alex-17
2023-08-08 10:50:06 -06:00
parent 460efb2497
commit b2e475200c
25 changed files with 1209 additions and 233 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ui/mod.rs
+52 -26
View File
@@ -22,7 +22,7 @@ use crate::ui::utils::{
layout_button_paragraph_borderless, layout_paragraph_borderless, logo_block, show_cursor,
style_block_highlight, style_default, style_default_bold, style_failure, style_help,
style_highlight, style_primary, style_secondary, style_system_function, title_block,
title_block_centered, vertical_chunks, vertical_chunks_with_margin,
title_block_centered, vertical_chunks_with_margin,
};
mod radarr_ui;
@@ -209,7 +209,7 @@ pub fn draw_large_popup_over<B: Backend>(
draw_popup_over(f, app, area, background_fn, popup_fn, 75, 75);
}
pub fn draw_large_popup_over_ui<B: Backend, T: DrawUi>(
pub fn draw_large_popup_over_background_fn_with_ui<B: Backend, T: DrawUi>(
f: &mut Frame<'_, B>,
app: &mut App<'_>,
area: Rect,
@@ -296,6 +296,14 @@ pub struct TableProps<'a, T> {
pub help: Option<&'static str>,
}
pub struct ListProps<'a, T> {
pub content: &'a mut StatefulList<T>,
pub title: &'static str,
pub is_loading: bool,
pub is_popup: bool,
pub help: Option<&'static str>,
}
fn draw_table<'a, B, T, F>(
f: &mut Frame<'_, B>,
content_area: Rect,
@@ -315,23 +323,7 @@ fn draw_table<'a, B, T, F>(
help,
} = table_props;
let content_area = if let Some(help_string) = help {
let chunks = vertical_chunks(
vec![Constraint::Min(0), Constraint::Length(2)],
content_area,
);
let mut help_text = Text::from(format!(" {}", help_string));
help_text.patch_style(style_help());
let help_paragraph = Paragraph::new(help_text)
.block(layout_block_top_border())
.alignment(Alignment::Left);
f.render_widget(help_paragraph, chunks[1]);
chunks[0]
} else {
content_area
};
let content_area = draw_help(f, content_area, help);
if !content.items.is_empty() {
let rows = content.items.iter().map(row_mapper);
@@ -587,20 +579,54 @@ pub fn draw_selectable_list<'a, B: Backend, T>(
pub fn draw_list_box<'a, B: Backend, T>(
f: &mut Frame<'_, B>,
area: Rect,
content: &'a mut StatefulList<T>,
title: &str,
item_mapper: impl Fn(&T) -> ListItem<'a>,
is_loading: bool,
list_props: ListProps<'a, T>,
) {
let block = title_block(title);
let ListProps {
content,
title,
is_loading,
is_popup,
help,
} = list_props;
let (content_area, block) = if is_popup {
f.render_widget(title_block(title), area);
(draw_help(f, area, help), borderless_block())
} else {
(area, title_block(title))
};
if !content.items.is_empty() {
let items: Vec<ListItem<'_>> = content.items.iter().map(item_mapper).collect();
let list = List::new(items).block(title_block(title));
let mut list = List::new(items).block(block);
f.render_stateful_widget(list, area, &mut content.state);
if is_popup {
list = list.highlight_style(style_highlight());
}
f.render_stateful_widget(list, content_area, &mut content.state);
} else {
loading(f, block, area, is_loading);
loading(f, block, content_area, is_loading);
}
}
fn draw_help<B: Backend>(f: &mut Frame<'_, B>, area: Rect, help: Option<&str>) -> Rect {
if let Some(help_string) = help {
let chunks =
vertical_chunks_with_margin(vec![Constraint::Min(0), Constraint::Length(2)], area, 1);
let mut help_test = Text::from(format!(" {}", help_string));
help_test.patch_style(style_help());
let help_paragraph = Paragraph::new(help_test)
.block(layout_block_top_border())
.alignment(Alignment::Left);
f.render_widget(help_paragraph, chunks[1]);
chunks[0]
} else {
area
}
}
src/ui/radarr_ui/edit_collection_ui.rs
+3 -2
View File
@@ -15,7 +15,8 @@ use crate::ui::utils::{
};
use crate::ui::{
draw_button, draw_checkbox_with_label, draw_drop_down_menu_button, draw_drop_down_popup,
draw_large_popup_over_ui, draw_medium_popup_over, draw_popup, draw_text_box_with_label, DrawUi,
draw_large_popup_over_background_fn_with_ui, draw_medium_popup_over, draw_popup,
draw_text_box_with_label, DrawUi,
};
pub(super) struct EditCollectionUi {}
@@ -62,7 +63,7 @@ impl DrawUi for EditCollectionUi {
draw_edit_collection_prompt,
),
_ if COLLECTION_DETAILS_BLOCKS.contains(&context) => {
draw_large_popup_over_ui::<B, CollectionDetailsUi>(
draw_large_popup_over_background_fn_with_ui::<B, CollectionDetailsUi>(
f,
app,
content_rect,
src/ui/radarr_ui/edit_movie_ui.rs
+8 -2
View File
@@ -15,7 +15,8 @@ use crate::ui::utils::{
};
use crate::ui::{
draw_button, draw_checkbox_with_label, draw_drop_down_menu_button, draw_drop_down_popup,
draw_large_popup_over_ui, draw_medium_popup_over, draw_popup, draw_text_box_with_label, DrawUi,
draw_large_popup_over_background_fn_with_ui, draw_medium_popup_over, draw_popup,
draw_text_box_with_label, DrawUi,
};
pub(super) struct EditMovieUi {}
@@ -58,7 +59,12 @@ impl DrawUi for EditMovieUi {
draw_medium_popup_over(f, app, content_rect, draw_library, draw_edit_movie_prompt);
}
_ if MOVIE_DETAILS_BLOCKS.contains(&context) => {
draw_large_popup_over_ui::<B, MovieDetailsUi>(f, app, content_rect, draw_library);
draw_large_popup_over_background_fn_with_ui::<B, MovieDetailsUi>(
f,
app,
content_rect,
draw_library,
);
draw_popup(f, app, draw_edit_movie_prompt, 60, 60);
}
_ => (),
src/ui/radarr_ui/mod.rs
+11 -7
View File
@@ -1,5 +1,4 @@
use std::iter;
use std::ops::Sub;
use chrono::{Duration, Utc};
use tui::backend::Backend;
@@ -13,6 +12,7 @@ use tui::Frame;
use crate::app::radarr::{
ActiveRadarrBlock, RadarrData, ADD_MOVIE_BLOCKS, COLLECTION_DETAILS_BLOCKS, DELETE_MOVIE_BLOCKS,
EDIT_COLLECTION_BLOCKS, EDIT_MOVIE_BLOCKS, FILTER_BLOCKS, MOVIE_DETAILS_BLOCKS, SEARCH_BLOCKS,
SYSTEM_DETAILS_BLOCKS,
};
use crate::app::App;
use crate::logos::RADARR_LOGO;
@@ -21,6 +21,7 @@ use crate::models::Route;
use crate::ui::draw_selectable_list;
use crate::ui::draw_tabs;
use crate::ui::loading;
use crate::ui::radarr_ui::system_details_ui::SystemDetailsUi;
use crate::ui::radarr_ui::system_ui::SystemUi;
use crate::ui::radarr_ui::{
add_movie_ui::AddMoviesUi, collection_details_ui::CollectionDetailsUi,
@@ -45,7 +46,9 @@ mod edit_collection_ui;
mod edit_movie_ui;
mod library_ui;
mod movie_details_ui;
mod radarr_ui_utils;
mod root_folders_ui;
mod system_details_ui;
mod system_ui;
pub(super) struct RadarrUi {}
@@ -73,6 +76,9 @@ impl DrawUi for RadarrUi {
| ActiveRadarrBlock::AddRootFolderPrompt
| ActiveRadarrBlock::DeleteRootFolderPrompt => RootFoldersUi::draw(f, app, content_rect),
ActiveRadarrBlock::System => SystemUi::draw(f, app, content_rect),
_ if SYSTEM_DETAILS_BLOCKS.contains(&active_radarr_block) => {
SystemDetailsUi::draw(f, app, content_rect)
}
_ if MOVIE_DETAILS_BLOCKS.contains(&active_radarr_block) => {
MovieDetailsUi::draw(f, app, content_rect)
}
@@ -143,15 +149,13 @@ fn draw_stats_context<B: Backend>(f: &mut Frame<'_, B>, app: &App<'_>, area: Rec
.block(borderless_block())
.style(style_bold());
let uptime = Utc::now().sub(start_time.to_owned());
let uptime = Utc::now() - start_time.to_owned();
let days = uptime.num_days();
let day_difference = uptime.sub(Duration::days(days));
let day_difference = uptime - Duration::days(days);
let hours = day_difference.num_hours();
let hour_difference = day_difference.sub(Duration::hours(hours));
let hour_difference = day_difference - Duration::hours(hours);
let minutes = hour_difference.num_minutes();
let seconds = hour_difference
.sub(Duration::minutes(minutes))
.num_seconds();
let seconds = (hour_difference - Duration::minutes(minutes)).num_seconds();
let uptime_paragraph = Paragraph::new(Text::from(format!(
"Uptime: {}d {:0width$}:{:0width$}:{:0width$}",
src/ui/radarr_ui/radarr_ui_utils.rs
+44
View File
@@ -0,0 +1,44 @@
use crate::ui::utils::{style_default, style_failure, style_secondary};
use tui::style::{Color, Modifier, Style};
#[cfg(test)]
#[path = "radarr_ui_utils_tests.rs"]
mod radarr_ui_utils_tests;
pub(super) fn determine_log_style_by_level(level: &str) -> Style {
match level.to_lowercase().as_str() {
"trace" => Style::default().fg(Color::Gray),
"debug" => Style::default().fg(Color::Blue),
"info" => style_default(),
"warn" => style_secondary(),
"error" => style_failure(),
"fatal" => style_failure().add_modifier(Modifier::BOLD),
_ => style_default(),
}
}
pub(super) fn convert_to_minutes_hours_days(time: i64) -> String {
if time < 60 {
if time == 0 {
"now".to_owned()
} else if time == 1 {
format!("{} minute", time)
} else {
format!("{} minutes", time)
}
} else if time / 60 < 24 {
let hours = time / 60;
if hours == 1 {
format!("{} hour", hours)
} else {
format!("{} hours", hours)
}
} else {
let days = time / (60 * 24);
if days == 1 {
format!("{} day", days)
} else {
format!("{} days", days)
}
}
}
src/ui/radarr_ui/system_ui_tests.rs → src/ui/radarr_ui/radarr_ui_utils_tests.rs
View File
src/ui/radarr_ui/system_details_ui.rs
+123
View File
@@ -0,0 +1,123 @@
use crate::app::radarr::ActiveRadarrBlock;
use crate::app::App;
use crate::models::Route;
use crate::ui::radarr_ui::radarr_ui_utils::determine_log_style_by_level;
use crate::ui::radarr_ui::system_ui::{
draw_queued_events, draw_system_ui_layout, extract_task_props, TASK_TABLE_CONSTRAINTS,
TASK_TABLE_HEADERS,
};
use crate::ui::utils::{style_primary, title_block};
use crate::ui::{
draw_large_popup_over, draw_list_box, draw_medium_popup_over, draw_prompt_box,
draw_prompt_popup_over, draw_table, DrawUi, ListProps, TableProps,
};
use tui::backend::Backend;
use tui::layout::Rect;
use tui::text::{Span, Text};
use tui::widgets::{Cell, ListItem, Row};
use tui::Frame;
pub(super) struct SystemDetailsUi {}
impl DrawUi for SystemDetailsUi {
fn draw<B: Backend>(f: &mut Frame<'_, B>, app: &mut App<'_>, content_rect: Rect) {
if let Route::Radarr(active_radarr_block, _) = *app.get_current_route() {
match active_radarr_block {
ActiveRadarrBlock::SystemLogs => {
draw_large_popup_over(f, app, content_rect, draw_system_ui_layout, draw_logs_popup)
}
ActiveRadarrBlock::SystemTasks | ActiveRadarrBlock::SystemTaskStartConfirmPrompt => {
draw_large_popup_over(
f,
app,
content_rect,
draw_system_ui_layout,
draw_tasks_popup,
)
}
ActiveRadarrBlock::SystemQueue => draw_medium_popup_over(
f,
app,
content_rect,
draw_system_ui_layout,
draw_queued_events,
),
_ => (),
}
}
}
}
fn draw_logs_popup<B: Backend>(f: &mut Frame<'_, B>, app: &mut App<'_>, area: Rect) {
draw_list_box(
f,
area,
|log| {
let log_line = log.to_string();
let level = log.text.split('|').collect::<Vec<&str>>()[1];
let style = determine_log_style_by_level(level);
ListItem::new(Text::from(Span::raw(log_line))).style(style)
},
ListProps {
content: &mut app.data.radarr_data.log_details,
title: "Log Details",
is_loading: app.is_loading,
is_popup: true,
help: Some("<esc> close | <↑↓←→> scroll"),
},
);
}
fn draw_tasks_popup<B: Backend>(f: &mut Frame<'_, B>, app: &mut App<'_>, area: Rect) {
let tasks_popup_table = |f: &mut Frame<'_, B>, app: &mut App<'_>, area: Rect| {
draw_table(
f,
area,
title_block("Tasks"),
TableProps {
content: &mut app.data.radarr_data.tasks,
table_headers: TASK_TABLE_HEADERS.to_vec(),
constraints: TASK_TABLE_CONSTRAINTS.to_vec(),
help: None,
},
|task| {
let task_props = extract_task_props(task);
Row::new(vec![
Cell::from(task_props.name),
Cell::from(task_props.interval),
Cell::from(task_props.last_execution),
Cell::from(task_props.last_duration),
Cell::from(task_props.next_execution),
])
.style(style_primary())
},
app.is_loading,
true,
)
};
if matches!(
app.get_current_route(),
Route::Radarr(ActiveRadarrBlock::SystemTaskStartConfirmPrompt, _)
) {
draw_prompt_popup_over(f, app, area, tasks_popup_table, draw_start_task_prompt)
} else {
tasks_popup_table(f, app, area);
}
}
fn draw_start_task_prompt<B: Backend>(f: &mut Frame<'_, B>, app: &mut App<'_>, prompt_area: Rect) {
draw_prompt_box(
f,
prompt_area,
"Start Task",
format!(
"Do you want to manually start this task: {}?",
app.data.radarr_data.tasks.current_selection().name
)
.as_str(),
app.data.radarr_data.prompt_confirm,
);
}
src/ui/radarr_ui/system_ui.rs
+80 -101
View File
@@ -1,31 +1,45 @@
use crate::ui::utils::{layout_block_top_border, style_help, style_primary, style_secondary};
use crate::ui::{draw_table, TableProps};
use crate::models::radarr_models::Task;
use crate::ui::radarr_ui::radarr_ui_utils::{
convert_to_minutes_hours_days, determine_log_style_by_level,
};
use crate::ui::utils::{layout_block_top_border, style_help, style_primary};
use crate::ui::{draw_table, ListProps, TableProps};
use crate::{
app::{radarr::ActiveRadarrBlock, App},
models::Route,
ui::{
draw_list_box,
utils::{horizontal_chunks, style_default, style_failure, title_block, vertical_chunks},
utils::{horizontal_chunks, title_block, vertical_chunks},
DrawUi,
},
};
use chrono::Utc;
use std::ops::Sub;
use tui::layout::Alignment;
use tui::style::Modifier;
use tui::text::{Span, Text};
use tui::widgets::{Cell, Paragraph, Row};
use tui::{
backend::Backend,
layout::{Constraint, Rect},
style::{Color, Style},
widgets::ListItem,
Frame,
};
#[cfg(test)]
#[path = "system_ui_tests.rs"]
mod system_ui_tests;
pub(super) const TASK_TABLE_HEADERS: [&str; 5] = [
"Name",
"Interval",
"Last Execution",
"Last Duration",
"Next Execution",
];
pub(super) const TASK_TABLE_CONSTRAINTS: [Constraint; 5] = [
Constraint::Percentage(30),
Constraint::Percentage(12),
Constraint::Percentage(18),
Constraint::Percentage(18),
Constraint::Percentage(22),
];
pub(super) struct SystemUi {}
@@ -40,7 +54,11 @@ impl DrawUi for SystemUi {
}
}
fn draw_system_ui_layout<B: Backend>(f: &mut Frame<'_, B>, app: &mut App<'_>, area: Rect) {
pub(super) fn draw_system_ui_layout<B: Backend>(
f: &mut Frame<'_, B>,
app: &mut App<'_>,
area: Rect,
) {
let vertical_chunks = vertical_chunks(
vec![
Constraint::Ratio(1, 2),
@@ -56,54 +74,31 @@ fn draw_system_ui_layout<B: Backend>(f: &mut Frame<'_, B>, app: &mut App<'_>, ar
);
draw_tasks(f, app, horizontal_chunks[0]);
draw_events(f, app, horizontal_chunks[1]);
draw_queued_events(f, app, horizontal_chunks[1]);
draw_logs(f, app, vertical_chunks[1]);
draw_help(f, app, vertical_chunks[2]);
}
fn draw_tasks<B: Backend>(f: &mut Frame<'_, B>, app: &mut App<'_>, area: Rect) {
let block = title_block("Tasks");
draw_table(
f,
area,
block,
title_block("Tasks"),
TableProps {
content: &mut app.data.radarr_data.tasks,
table_headers: vec![
"Name",
"Interval",
"Last Execution",
"Last Duration",
"Next Execution",
],
constraints: vec![
Constraint::Percentage(30),
Constraint::Percentage(12),
Constraint::Percentage(18),
Constraint::Percentage(18),
Constraint::Percentage(22),
],
table_headers: TASK_TABLE_HEADERS.to_vec(),
constraints: TASK_TABLE_CONSTRAINTS.to_vec(),
help: None,
},
|task| {
let interval = convert_to_minutes_hours_days(*task.interval.as_i64().as_ref().unwrap());
let last_duration = &task.last_duration[..8];
let next_execution =
convert_to_minutes_hours_days(task.next_execution.sub(Utc::now()).num_minutes());
let last_execution =
convert_to_minutes_hours_days(Utc::now().sub(task.last_execution).num_minutes());
let last_execution_string = if last_execution != "now" {
format!("{} ago", last_execution)
} else {
last_execution
};
let task_props = extract_task_props(task);
Row::new(vec![
Cell::from(task.name.clone()),
Cell::from(interval),
Cell::from(last_execution_string),
Cell::from(last_duration.to_owned()),
Cell::from(next_execution),
Cell::from(task_props.name),
Cell::from(task_props.interval),
Cell::from(task_props.last_execution),
Cell::from(task_props.last_duration),
Cell::from(task_props.next_execution),
])
.style(style_primary())
},
@@ -112,14 +107,13 @@ fn draw_tasks<B: Backend>(f: &mut Frame<'_, B>, app: &mut App<'_>, area: Rect) {
);
}
fn draw_events<B: Backend>(f: &mut Frame<'_, B>, app: &mut App<'_>, area: Rect) {
let block = title_block("Events");
pub(super) fn draw_queued_events<B: Backend>(f: &mut Frame<'_, B>, app: &mut App<'_>, area: Rect) {
draw_table(
f,
area,
block,
title_block("Queued Events"),
TableProps {
content: &mut app.data.radarr_data.events,
content: &mut app.data.radarr_data.queued_events,
table_headers: vec!["Trigger", "Status", "Name", "Queued", "Started", "Duration"],
constraints: vec![
Constraint::Percentage(13),
@@ -151,7 +145,11 @@ fn draw_events<B: Backend>(f: &mut Frame<'_, B>, app: &mut App<'_>, area: Rect)
String::new()
};
let duration = &event.duration[..8];
let duration = if event.duration.is_some() {
&event.duration.as_ref().unwrap()[..8]
} else {
""
};
Row::new(vec![
Cell::from(event.trigger.clone()),
@@ -172,31 +170,20 @@ fn draw_logs<B: Backend>(f: &mut Frame<'_, B>, app: &mut App<'_>, area: Rect) {
draw_list_box(
f,
area,
&mut app.data.radarr_data.logs,
"Logs",
|log| {
let log_line = if log.exception.is_some() {
Text::from(Span::raw(format!(
"{}|{}|{}|{}|{}",
log.time,
log.level.as_ref().unwrap().to_uppercase(),
log.logger.as_ref().unwrap(),
log.exception_type.as_ref().unwrap(),
log.exception.as_ref().unwrap()
)))
} else {
Text::from(Span::raw(format!(
"{}|{}|{}|{}",
log.time,
log.level.as_ref().unwrap().to_uppercase(),
log.logger.as_ref().unwrap(),
log.message.as_ref().unwrap()
)))
};
let log_line = log.to_string();
let level = log_line.split('|').collect::<Vec<&str>>()[1];
let style = determine_log_style_by_level(level);
ListItem::new(log_line).style(determine_log_style_by_level(log.level.as_ref().unwrap()))
ListItem::new(Text::from(Span::raw(log_line))).style(style)
},
ListProps {
content: &mut app.data.radarr_data.logs,
title: "Logs",
is_loading: app.is_loading,
is_popup: false,
help: None,
},
app.is_loading,
);
}
@@ -218,40 +205,32 @@ fn draw_help<B: Backend>(f: &mut Frame<'_, B>, app: &mut App<'_>, area: Rect) {
f.render_widget(help_paragraph, area);
}
fn determine_log_style_by_level(level: &str) -> Style {
match level.to_lowercase().as_str() {
"trace" => Style::default().fg(Color::Gray),
"debug" => Style::default().fg(Color::Blue),
"info" => style_default(),
"warn" => style_secondary(),
"error" => style_failure(),
"fatal" => style_failure().add_modifier(Modifier::BOLD),
_ => style_default(),
}
pub(super) struct TaskProps {
pub(super) name: String,
pub(super) interval: String,
pub(super) last_execution: String,
pub(super) last_duration: String,
pub(super) next_execution: String,
}
fn convert_to_minutes_hours_days(time: i64) -> String {
if time < 60 {
if time == 0 {
"now".to_owned()
} else if time == 1 {
format!("{} minute", time)
} else {
format!("{} minutes", time)
}
} else if time / 60 < 24 {
let hours = time / 60;
if hours == 1 {
format!("{} hour", hours)
} else {
format!("{} hours", hours)
}
pub(super) fn extract_task_props(task: &Task) -> TaskProps {
let interval = convert_to_minutes_hours_days(*task.interval.as_i64().as_ref().unwrap());
let last_duration = &task.last_duration[..8];
let next_execution =
convert_to_minutes_hours_days((task.next_execution - Utc::now()).num_minutes());
let last_execution =
convert_to_minutes_hours_days((Utc::now() - task.last_execution).num_minutes());
let last_execution_string = if last_execution != "now" {
format!("{} ago", last_execution)
} else {
let days = time / (60 * 24);
if days == 1 {
format!("{} day", days)
} else {
format!("{} days", days)
}
last_execution
};
TaskProps {
name: task.name.clone(),
interval,
last_execution: last_execution_string,
last_duration: last_duration.to_owned(),
next_execution,
}
}