612 lines
18 KiB
Rust
612 lines
18 KiB
Rust
use chrono::Utc;
|
|
use deunicode::deunicode;
|
|
use ratatui::Frame;
|
|
use ratatui::layout::{Constraint, Layout, Rect};
|
|
use ratatui::style::Stylize;
|
|
use ratatui::text::Line;
|
|
use ratatui::widgets::{Cell, Paragraph, Row, Wrap};
|
|
use regex::Regex;
|
|
|
|
use crate::app::App;
|
|
use crate::models::Route;
|
|
use crate::models::lidarr_models::{Album, LidarrHistoryItem, LidarrRelease};
|
|
use crate::models::servarr_data::lidarr::lidarr_data::{ARTIST_DETAILS_BLOCKS, ActiveLidarrBlock};
|
|
use crate::ui::lidarr_ui::library::album_details_ui::AlbumDetailsUi;
|
|
use crate::ui::lidarr_ui::library::delete_album_ui::DeleteAlbumUi;
|
|
use crate::ui::lidarr_ui::lidarr_ui_utils::create_history_event_details;
|
|
use crate::ui::styles::{ManagarrStyle, secondary_style};
|
|
use crate::ui::utils::decorate_peer_style;
|
|
use crate::ui::utils::{
|
|
borderless_block, get_width_from_percentage, layout_block_top_border, title_block,
|
|
};
|
|
use crate::ui::widgets::confirmation_prompt::ConfirmationPrompt;
|
|
use crate::ui::widgets::loading_block::LoadingBlock;
|
|
use crate::ui::widgets::managarr_table::ManagarrTable;
|
|
use crate::ui::widgets::message::Message;
|
|
use crate::ui::widgets::popup::{Popup, Size};
|
|
use crate::ui::{DrawUi, draw_popup, draw_tabs};
|
|
use crate::utils::convert_to_gb;
|
|
use ratatui::layout::Alignment;
|
|
use ratatui::text::Text;
|
|
use serde_json::Number;
|
|
|
|
#[cfg(test)]
|
|
#[path = "artist_details_ui_tests.rs"]
|
|
mod artist_details_ui_tests;
|
|
|
|
pub(super) struct ArtistDetailsUi;
|
|
|
|
impl DrawUi for ArtistDetailsUi {
|
|
fn accepts(route: Route) -> bool {
|
|
let Route::Lidarr(active_lidarr_block, _) = route else {
|
|
return false;
|
|
};
|
|
AlbumDetailsUi::accepts(route)
|
|
|| DeleteAlbumUi::accepts(route)
|
|
|| ARTIST_DETAILS_BLOCKS.contains(&active_lidarr_block)
|
|
}
|
|
|
|
fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
let route = app.get_current_route();
|
|
if let Route::Lidarr(active_lidarr_block, _) = route {
|
|
let draw_artist_details_popup = |f: &mut Frame<'_>, app: &mut App<'_>, popup_area: Rect| {
|
|
f.render_widget(
|
|
title_block(
|
|
&app
|
|
.data
|
|
.lidarr_data
|
|
.artists
|
|
.current_selection()
|
|
.artist_name
|
|
.text,
|
|
),
|
|
popup_area,
|
|
);
|
|
let [description_area, detail_area] =
|
|
Layout::vertical([Constraint::Length(14), Constraint::Fill(0)])
|
|
.margin(1)
|
|
.areas(popup_area);
|
|
draw_artist_description(f, app, description_area);
|
|
let content_area = draw_tabs(
|
|
f,
|
|
detail_area,
|
|
"Artist Details",
|
|
&app.data.lidarr_data.artist_info_tabs,
|
|
);
|
|
draw_artist_details(f, app, content_area);
|
|
|
|
match active_lidarr_block {
|
|
_ if DeleteAlbumUi::accepts(route) => DeleteAlbumUi::draw(f, app, area),
|
|
ActiveLidarrBlock::ArtistHistoryDetails => {
|
|
draw_artist_history_item_details_popup(f, app);
|
|
}
|
|
ActiveLidarrBlock::AutomaticallySearchArtistPrompt => {
|
|
let prompt = format!(
|
|
"Do you want to trigger an automatic search of your indexers for all monitored album(s) for the artist: {}?",
|
|
app.data.lidarr_data.artists.current_selection().artist_name
|
|
);
|
|
let confirmation_prompt = ConfirmationPrompt::new()
|
|
.title("Automatic Artist Search")
|
|
.prompt(&prompt)
|
|
.yes_no_value(app.data.lidarr_data.prompt_confirm);
|
|
|
|
f.render_widget(
|
|
Popup::new(confirmation_prompt).size(Size::MediumPrompt),
|
|
f.area(),
|
|
);
|
|
}
|
|
ActiveLidarrBlock::UpdateAndScanArtistPrompt => {
|
|
let prompt = format!(
|
|
"Do you want to trigger an update and disk scan for the artist: {}?",
|
|
app.data.lidarr_data.artists.current_selection().artist_name
|
|
);
|
|
let confirmation_prompt = ConfirmationPrompt::new()
|
|
.title("Update and Scan")
|
|
.prompt(&prompt)
|
|
.yes_no_value(app.data.lidarr_data.prompt_confirm);
|
|
|
|
f.render_widget(
|
|
Popup::new(confirmation_prompt).size(Size::MediumPrompt),
|
|
f.area(),
|
|
);
|
|
}
|
|
ActiveLidarrBlock::ManualArtistSearchConfirmPrompt => {
|
|
draw_manual_artist_search_confirm_prompt(f, app);
|
|
}
|
|
_ => (),
|
|
}
|
|
};
|
|
|
|
draw_popup(f, app, draw_artist_details_popup, Size::XXLarge);
|
|
|
|
if AlbumDetailsUi::accepts(route) {
|
|
AlbumDetailsUi::draw(f, app, area);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn draw_artist_description(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
let current_selection = app.data.lidarr_data.artists.current_selection();
|
|
let monitored = if current_selection.monitored {
|
|
"Yes"
|
|
} else {
|
|
"No"
|
|
};
|
|
let quality_profile = app
|
|
.data
|
|
.lidarr_data
|
|
.quality_profile_map
|
|
.get_by_left(¤t_selection.quality_profile_id)
|
|
.cloned()
|
|
.unwrap_or_default();
|
|
let metadata_profile = app
|
|
.data
|
|
.lidarr_data
|
|
.metadata_profile_map
|
|
.get_by_left(¤t_selection.metadata_profile_id)
|
|
.cloned()
|
|
.unwrap_or_default();
|
|
let overview = Regex::new(r"[\r\n\t]")
|
|
.unwrap()
|
|
.replace_all(
|
|
&deunicode(
|
|
current_selection
|
|
.overview
|
|
.as_ref()
|
|
.unwrap_or(&String::new()),
|
|
),
|
|
"",
|
|
)
|
|
.to_string();
|
|
|
|
let mut artist_description = vec![
|
|
Line::from(vec![
|
|
"Artist: ".primary().bold(),
|
|
current_selection.artist_name.text.clone().primary().bold(),
|
|
]),
|
|
Line::from(vec![
|
|
"Overview: ".primary().bold(),
|
|
overview.default_color(),
|
|
]),
|
|
Line::from(vec![
|
|
"Disambiguation: ".primary().bold(),
|
|
current_selection
|
|
.disambiguation
|
|
.clone()
|
|
.unwrap_or_default()
|
|
.default_color(),
|
|
]),
|
|
Line::from(vec![
|
|
"Type: ".primary().bold(),
|
|
current_selection
|
|
.artist_type
|
|
.clone()
|
|
.unwrap_or_default()
|
|
.default_color(),
|
|
]),
|
|
Line::from(vec![
|
|
"Status: ".primary().bold(),
|
|
current_selection.status.to_display_str().default_color(),
|
|
]),
|
|
Line::from(vec![
|
|
"Genres: ".primary().bold(),
|
|
current_selection.genres.join(", ").default_color(),
|
|
]),
|
|
Line::from(vec![
|
|
"Rating: ".primary().bold(),
|
|
current_selection
|
|
.ratings
|
|
.as_ref()
|
|
.map_or_else(
|
|
|| "N/A".to_owned(),
|
|
|r| format!("{}%", (r.value * 10.0) as i32),
|
|
)
|
|
.default_color(),
|
|
]),
|
|
Line::from(vec![
|
|
"Path: ".primary().bold(),
|
|
current_selection.path.clone().default_color(),
|
|
]),
|
|
Line::from(vec![
|
|
"Quality Profile: ".primary().bold(),
|
|
quality_profile.default_color(),
|
|
]),
|
|
Line::from(vec![
|
|
"Metadata Profile: ".primary().bold(),
|
|
metadata_profile.default_color(),
|
|
]),
|
|
Line::from(vec![
|
|
"Monitored: ".primary().bold(),
|
|
monitored.default_color(),
|
|
]),
|
|
];
|
|
|
|
if let Some(stats) = current_selection.statistics.as_ref() {
|
|
let size = convert_to_gb(stats.size_on_disk);
|
|
artist_description.extend(vec![
|
|
Line::from(vec![
|
|
"Albums: ".primary().bold(),
|
|
stats.album_count.to_string().default_color(),
|
|
]),
|
|
Line::from(vec![
|
|
"Tracks: ".primary().bold(),
|
|
format!("{}/{}", stats.track_file_count, stats.total_track_count).default_color(),
|
|
]),
|
|
Line::from(vec![
|
|
"Size on Disk: ".primary().bold(),
|
|
format!("{size:.2} GB").default_color(),
|
|
]),
|
|
]);
|
|
}
|
|
|
|
let description_paragraph = Paragraph::new(artist_description)
|
|
.block(borderless_block())
|
|
.wrap(Wrap { trim: true });
|
|
f.render_widget(description_paragraph, area);
|
|
}
|
|
|
|
fn draw_artist_details(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
if let Route::Lidarr(active_lidarr_block, _) =
|
|
app.data.lidarr_data.artist_info_tabs.get_active_route()
|
|
{
|
|
match active_lidarr_block {
|
|
ActiveLidarrBlock::ArtistDetails => draw_albums_table(f, app, area),
|
|
ActiveLidarrBlock::ArtistHistory => draw_artist_history_table(f, app, area),
|
|
ActiveLidarrBlock::ManualArtistSearch => draw_artist_releases(f, app, area),
|
|
_ => (),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn draw_albums_table(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
if let Route::Lidarr(active_lidarr_block, _) = app.get_current_route() {
|
|
let current_selection = if app.data.lidarr_data.albums.is_empty() {
|
|
Album::default()
|
|
} else {
|
|
app.data.lidarr_data.albums.current_selection().clone()
|
|
};
|
|
let content = Some(&mut app.data.lidarr_data.albums);
|
|
let album_row_mapping = |album: &Album| {
|
|
album.title.scroll_left_or_reset(
|
|
get_width_from_percentage(area, 33),
|
|
*album == current_selection,
|
|
app.ui_scroll_tick_count == 0,
|
|
);
|
|
let monitored = if album.monitored { "🏷" } else { "" };
|
|
let album_type = album.album_type.clone().unwrap_or_default();
|
|
let release_date = album
|
|
.release_date
|
|
.map_or_else(|| "N/A".to_owned(), |d| d.format("%Y-%m-%d").to_string());
|
|
let track_count = album.statistics.as_ref().map_or_else(
|
|
|| "0/0".to_owned(),
|
|
|s| format!("{}/{}", s.track_file_count, s.total_track_count),
|
|
);
|
|
let size = album
|
|
.statistics
|
|
.as_ref()
|
|
.map_or(0f64, |s| convert_to_gb(s.size_on_disk));
|
|
let duration_mins = album.duration / 60000;
|
|
|
|
let row = Row::new(vec![
|
|
Cell::from(monitored.to_owned()),
|
|
Cell::from(album.title.to_string()),
|
|
Cell::from(album_type),
|
|
Cell::from(track_count),
|
|
Cell::from(format!("{duration_mins} min")),
|
|
Cell::from(release_date),
|
|
Cell::from(format!("{size:.2} GB")),
|
|
]);
|
|
|
|
if !album.monitored {
|
|
row.unmonitored()
|
|
} else if let Some(stats) = album.statistics.as_ref() {
|
|
if stats.track_file_count == stats.total_track_count && stats.total_track_count > 0 {
|
|
row.downloaded()
|
|
} else if let Some(release_date) = album.release_date.as_ref() {
|
|
if release_date > &Utc::now() {
|
|
row.unreleased()
|
|
} else {
|
|
row.missing()
|
|
}
|
|
} else {
|
|
row.missing()
|
|
}
|
|
} else {
|
|
row.indeterminate()
|
|
}
|
|
};
|
|
|
|
let is_searching = active_lidarr_block == ActiveLidarrBlock::SearchAlbums;
|
|
let album_table = ManagarrTable::new(content, album_row_mapping)
|
|
.block(layout_block_top_border())
|
|
.loading(app.is_loading)
|
|
.searching(is_searching)
|
|
.search_produced_empty_results(active_lidarr_block == ActiveLidarrBlock::SearchAlbumsError)
|
|
.headers([
|
|
"Monitored",
|
|
"Title",
|
|
"Type",
|
|
"Tracks",
|
|
"Duration",
|
|
"Release Date",
|
|
"Size",
|
|
])
|
|
.constraints([
|
|
Constraint::Percentage(7),
|
|
Constraint::Percentage(35),
|
|
Constraint::Percentage(10),
|
|
Constraint::Percentage(10),
|
|
Constraint::Percentage(10),
|
|
Constraint::Percentage(13),
|
|
Constraint::Percentage(15),
|
|
]);
|
|
|
|
if is_searching {
|
|
album_table.show_cursor(f, area);
|
|
}
|
|
|
|
f.render_widget(album_table, area);
|
|
}
|
|
}
|
|
|
|
fn draw_artist_history_table(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
if !app.is_loading {
|
|
let current_selection = if app.data.lidarr_data.artist_history.is_empty() {
|
|
LidarrHistoryItem::default()
|
|
} else {
|
|
app
|
|
.data
|
|
.lidarr_data
|
|
.artist_history
|
|
.current_selection()
|
|
.clone()
|
|
};
|
|
|
|
if let Route::Lidarr(active_lidarr_block, _) = app.get_current_route() {
|
|
let history_row_mapping = |history_item: &LidarrHistoryItem| {
|
|
let LidarrHistoryItem {
|
|
source_title,
|
|
quality,
|
|
event_type,
|
|
date,
|
|
..
|
|
} = history_item;
|
|
|
|
source_title.scroll_left_or_reset(
|
|
get_width_from_percentage(area, 40),
|
|
current_selection == *history_item,
|
|
app.ui_scroll_tick_count == 0,
|
|
);
|
|
|
|
Row::new(vec![
|
|
Cell::from(source_title.to_string()),
|
|
Cell::from(event_type.to_string()),
|
|
Cell::from(quality.quality.name.to_owned()),
|
|
Cell::from(date.to_string()),
|
|
])
|
|
.primary()
|
|
};
|
|
let history_table = ManagarrTable::new(
|
|
Some(&mut app.data.lidarr_data.artist_history),
|
|
history_row_mapping,
|
|
)
|
|
.block(layout_block_top_border())
|
|
.loading(app.is_loading)
|
|
.sorting(active_lidarr_block == ActiveLidarrBlock::ArtistHistorySortPrompt)
|
|
.searching(active_lidarr_block == ActiveLidarrBlock::SearchArtistHistory)
|
|
.search_produced_empty_results(
|
|
active_lidarr_block == ActiveLidarrBlock::SearchArtistHistoryError,
|
|
)
|
|
.filtering(active_lidarr_block == ActiveLidarrBlock::FilterArtistHistory)
|
|
.filter_produced_empty_results(
|
|
active_lidarr_block == ActiveLidarrBlock::FilterArtistHistoryError,
|
|
)
|
|
.headers(["Source Title", "Event Type", "Quality", "Date"])
|
|
.constraints([
|
|
Constraint::Percentage(40),
|
|
Constraint::Percentage(20),
|
|
Constraint::Percentage(15),
|
|
Constraint::Percentage(25),
|
|
]);
|
|
|
|
if [
|
|
ActiveLidarrBlock::SearchArtistHistory,
|
|
ActiveLidarrBlock::FilterArtistHistory,
|
|
]
|
|
.contains(&active_lidarr_block)
|
|
{
|
|
history_table.show_cursor(f, area);
|
|
}
|
|
|
|
f.render_widget(history_table, area);
|
|
}
|
|
} else {
|
|
f.render_widget(
|
|
LoadingBlock::new(
|
|
app.is_loading || app.data.lidarr_data.albums.is_empty(),
|
|
layout_block_top_border(),
|
|
),
|
|
area,
|
|
);
|
|
}
|
|
}
|
|
|
|
fn draw_artist_history_item_details_popup(f: &mut Frame<'_>, app: &mut App<'_>) {
|
|
let current_selection = if app.data.lidarr_data.artist_history.is_empty() {
|
|
LidarrHistoryItem::default()
|
|
} else {
|
|
app
|
|
.data
|
|
.lidarr_data
|
|
.artist_history
|
|
.current_selection()
|
|
.clone()
|
|
};
|
|
|
|
let line_vec = create_history_event_details(current_selection);
|
|
let text = Text::from(line_vec);
|
|
|
|
let message = Message::new(text)
|
|
.title("Details")
|
|
.style(secondary_style())
|
|
.alignment(Alignment::Left);
|
|
|
|
f.render_widget(Popup::new(message).size(Size::NarrowLongMessage), f.area());
|
|
}
|
|
|
|
fn draw_artist_releases(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
|
|
let (current_selection, is_empty) = if app.data.lidarr_data.discography_releases.is_empty() {
|
|
(LidarrRelease::default(), true)
|
|
} else {
|
|
(
|
|
app
|
|
.data
|
|
.lidarr_data
|
|
.discography_releases
|
|
.current_selection()
|
|
.clone(),
|
|
app.data.lidarr_data.discography_releases.is_empty(),
|
|
)
|
|
};
|
|
|
|
if let Route::Lidarr(active_lidarr_block, _) = app.get_current_route() {
|
|
let release_row_mapping = |release: &LidarrRelease| {
|
|
let LidarrRelease {
|
|
protocol,
|
|
age,
|
|
title,
|
|
indexer,
|
|
size,
|
|
rejected,
|
|
seeders,
|
|
leechers,
|
|
quality,
|
|
..
|
|
} = release;
|
|
|
|
let age = format!("{age} days");
|
|
title.scroll_left_or_reset(
|
|
get_width_from_percentage(area, 35),
|
|
current_selection == *release
|
|
&& active_lidarr_block != ActiveLidarrBlock::ManualArtistSearchConfirmPrompt,
|
|
app.ui_scroll_tick_count == 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_or(Number::from(0u64))
|
|
.as_u64()
|
|
.unwrap_or_default();
|
|
let leechers = leechers
|
|
.clone()
|
|
.unwrap_or(Number::from(0u64))
|
|
.as_u64()
|
|
.unwrap_or_default();
|
|
|
|
decorate_peer_style(
|
|
seeders,
|
|
leechers,
|
|
Text::from(format!("{seeders} / {leechers}")),
|
|
)
|
|
};
|
|
|
|
let quality_name = 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(quality_name),
|
|
])
|
|
.primary()
|
|
};
|
|
let mut release_table = &mut app.data.lidarr_data.discography_releases;
|
|
let artist_release_table = ManagarrTable::new(Some(&mut release_table), release_row_mapping)
|
|
.block(layout_block_top_border())
|
|
.loading(app.is_loading || is_empty)
|
|
.sorting(active_lidarr_block == ActiveLidarrBlock::ManualArtistSearchSortPrompt)
|
|
.headers([
|
|
"Source", "Age", "⛔", "Title", "Indexer", "Size", "Peers", "Quality",
|
|
])
|
|
.constraints([
|
|
Constraint::Length(9),
|
|
Constraint::Length(10),
|
|
Constraint::Length(5),
|
|
Constraint::Percentage(35),
|
|
Constraint::Percentage(15),
|
|
Constraint::Length(12),
|
|
Constraint::Length(12),
|
|
Constraint::Percentage(10),
|
|
]);
|
|
|
|
f.render_widget(artist_release_table, area);
|
|
}
|
|
}
|
|
|
|
fn draw_manual_artist_search_confirm_prompt(f: &mut Frame<'_>, app: &mut App<'_>) {
|
|
let current_selection = app
|
|
.data
|
|
.lidarr_data
|
|
.discography_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 })
|
|
.left_aligned();
|
|
let confirmation_prompt = ConfirmationPrompt::new()
|
|
.title(title)
|
|
.prompt(&prompt)
|
|
.content(content_paragraph)
|
|
.yes_no_value(app.data.lidarr_data.prompt_confirm);
|
|
|
|
f.render_widget(Popup::new(confirmation_prompt).size(Size::Small), f.area());
|
|
} else {
|
|
let confirmation_prompt = ConfirmationPrompt::new()
|
|
.title(title)
|
|
.prompt(&prompt)
|
|
.yes_no_value(app.data.lidarr_data.prompt_confirm);
|
|
|
|
f.render_widget(
|
|
Popup::new(confirmation_prompt).size(Size::MediumPrompt),
|
|
f.area(),
|
|
);
|
|
}
|
|
}
|