Refresh, disk scan, and trigger auto-scan support and partial implementation for manual searches

2023-08-08 10:50:05 -06:00
parent 69981857d8
commit 1ad1b16668
12 changed files with 426 additions and 75 deletions
@@ -4,38 +4,95 @@ use tui::backend::Backend;
 use tui::layout::{Constraint, Rect};
 use tui::style::Style;
 use tui::text::{Spans, Text};
-use tui::widgets::{Block, Cell, Paragraph, Row, Wrap};
+use tui::widgets::{Cell, Paragraph, Row, Wrap};
 use tui::Frame;

 use crate::app::radarr::ActiveRadarrBlock;
 use crate::app::App;
-use crate::models::radarr_models::{Credit, MovieHistoryItem};
+use crate::models::radarr_models::{Credit, MovieHistoryItem, Release};
 use crate::models::Route;
 use crate::ui::utils::{
-  borderless_block, layout_block_bottom_border, spans_info_default, style_bold, style_default,
-  style_failure, style_success, style_warning, vertical_chunks,
+  borderless_block, get_width, layout_block_bottom_border, layout_block_top_border,
+  spans_info_default, style_bold, style_default, style_failure, style_primary, style_success,
+  style_warning, vertical_chunks,
 };
-use crate::ui::{draw_table, draw_tabs, loading, TableProps};
+use crate::ui::{
+  draw_prompt_box, draw_prompt_popup_over, draw_table, draw_tabs, loading, TableProps,
+};
+use crate::utils::convert_to_gb;

-pub(super) 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);
+pub(super) fn draw_movie_info_popup<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect) {
+  let (content_area, _) = draw_tabs(f, area, "Movie Info", &app.data.radarr_data.movie_info_tabs);

+  if let Route::Radarr(active_radarr_block) = app.get_current_route() {
+    match active_radarr_block {
+      ActiveRadarrBlock::AutomaticallySearchMoviePrompt => draw_prompt_popup_over(
+        f,
+        app,
+        content_area,
+        draw_movie_info,
+        draw_search_movie_prompt,
+      ),
+      ActiveRadarrBlock::RefreshAndScanPrompt => draw_prompt_popup_over(
+        f,
+        app,
+        content_area,
+        draw_movie_info,
+        draw_refresh_and_scan_prompt,
+      ),
+      _ => draw_movie_info(f, app, content_area),
+    }
+  }
+}
+
+fn draw_movie_info<B: Backend>(f: &mut Frame<'_, B>, 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, 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),
-      ActiveRadarrBlock::Crew => draw_movie_crew(f, app, content_area, 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),
      _ => (),
    }
  }
 }

-fn draw_file_info<B: Backend>(f: &mut Frame<'_, B>, app: &App, content_area: Rect, block: Block) {
+fn draw_search_movie_prompt<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, prompt_area: Rect) {
+  draw_prompt_box(
+    f,
+    prompt_area,
+    "  Confirm Search Movie?  ",
+    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_refresh_and_scan_prompt<B: Backend>(
+  f: &mut Frame<'_, B>,
+  app: &mut App,
+  prompt_area: Rect,
+) {
+  draw_prompt_box(
+    f,
+    prompt_area,
+    "  Confirm Refresh and Scan?  ",
+    format!(
+      "Do you want to trigger a refresh 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<B: Backend>(f: &mut Frame<'_, B>, app: &App, content_area: Rect) {
  let file_info = app.data.radarr_data.file_details.to_owned();

  if !file_info.is_empty() {
@@ -86,17 +143,13 @@ fn draw_file_info<B: Backend>(f: &mut Frame<'_, B>, app: &App, content_area: Rec
    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);
+    loading(f, layout_block_top_border(), content_area, app.is_loading);
  }
 }

-fn draw_movie_details<B: Backend>(
-  f: &mut Frame<'_, B>,
-  app: &App,
-  content_area: Rect,
-  block: Block,
-) {
+fn draw_movie_details<B: Backend>(f: &mut Frame<'_, B>, app: &App, content_area: Rect) {
  let movie_details = app.data.radarr_data.movie_details.get_text();
+  let block = layout_block_top_border();

  if !movie_details.is_empty() {
    let download_status = app
@@ -137,17 +190,13 @@ fn draw_movie_details<B: Backend>(
  }
 }

-fn draw_movie_history<B: Backend>(
-  f: &mut Frame<'_, B>,
-  app: &mut App,
-  content_area: Rect,
-  block: Block,
-) {
+fn draw_movie_history<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, content_area: Rect) {
  let current_selection = if app.data.radarr_data.movie_history.items.is_empty() {
    MovieHistoryItem::default()
  } else {
    app.data.radarr_data.movie_history.current_selection_clone()
  };
+  let block = layout_block_top_border();

  if app.data.radarr_data.movie_history.items.is_empty() && !app.is_loading {
    let no_history_paragraph = Paragraph::new(Text::from("No history"))
@@ -209,16 +258,11 @@ fn draw_movie_history<B: Backend>(
  }
 }

-fn draw_movie_cast<B: Backend>(
-  f: &mut Frame<'_, B>,
-  app: &mut App,
-  content_area: Rect,
-  block: Block,
-) {
+fn draw_movie_cast<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, content_area: Rect) {
  draw_table(
    f,
    content_area,
-    block,
+    layout_block_top_border(),
    TableProps {
      content: &mut app.data.radarr_data.movie_cast,
      constraints: iter::repeat(Constraint::Ratio(1, 2)).take(2).collect(),
@@ -241,16 +285,11 @@ fn draw_movie_cast<B: Backend>(
  )
 }

-fn draw_movie_crew<B: Backend>(
-  f: &mut Frame<'_, B>,
-  app: &mut App,
-  content_area: Rect,
-  block: Block,
-) {
+fn draw_movie_crew<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, content_area: Rect) {
  draw_table(
    f,
    content_area,
-    block,
+    layout_block_top_border(),
    TableProps {
      content: &mut app.data.radarr_data.movie_crew,
      constraints: iter::repeat(Constraint::Ratio(1, 3)).take(3).collect(),
@@ -275,6 +314,84 @@ fn draw_movie_crew<B: Backend>(
  );
 }

+fn draw_movie_releases<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, content_area: Rect) {
+  let current_selection = if app.data.radarr_data.movie_releases.items.is_empty() {
+    Release::default()
+  } else {
+    app
+      .data
+      .radarr_data
+      .movie_releases
+      .current_selection_clone()
+  };
+
+  draw_table(
+    f,
+    content_area,
+    layout_block_top_border(),
+    TableProps {
+      content: &mut app.data.radarr_data.movie_releases,
+      constraints: vec![
+        Constraint::Length(8),
+        Constraint::Length(10),
+        Constraint::Length(1),
+        Constraint::Percentage(40),
+        Constraint::Percentage(10),
+        Constraint::Length(8),
+        Constraint::Length(8),
+        Constraint::Percentage(10),
+        Constraint::Percentage(10),
+      ],
+      table_headers: vec![
+        "Source", "Age", "⛔", "Title", "Indexer", "Size", "Peers", "Language", "Quality",
+      ],
+    },
+    |release| {
+      let Release {
+        protocol,
+        age,
+        title,
+        indexer,
+        size,
+        rejected,
+        seeders,
+        leechers,
+        languages,
+        quality,
+        ..
+      } = release;
+      let age = format!("{} days", age.as_u64().unwrap());
+      title.scroll_or_reset(get_width(content_area), current_selection == *release);
+      indexer.scroll_or_reset(get_width(content_area), current_selection == *release);
+      let size = convert_to_gb(size.as_u64().unwrap());
+      let rejected_str = if *rejected { "⛔" } else { "" };
+      let seeders = seeders.as_u64().unwrap();
+      let leechers = leechers.as_u64().unwrap();
+      let peers = format!("{} / {}", seeders, leechers);
+      let language = if languages.is_some() {
+        languages.clone().unwrap()[0].name.clone()
+      } else {
+        String::default()
+      };
+      let quality = quality.quality.name.clone();
+
+      Row::new(vec![
+        Cell::from(protocol.clone()),
+        Cell::from(age),
+        Cell::from(rejected_str).style(determine_style_from_rejection(*rejected)),
+        Cell::from(title.to_string()),
+        Cell::from(indexer.to_string()),
+        Cell::from(format!("{} GB", size)),
+        Cell::from(peers).style(determine_peer_style(seeders, leechers)),
+        Cell::from(language),
+        Cell::from(quality),
+      ])
+      .style(style_primary())
+    },
+    app.is_loading,
+  )
+}
+
 fn determine_style_from_download_status(download_status: &str) -> Style {
  match download_status {
    "Downloaded" => style_success(),
@@ -283,3 +400,21 @@ fn determine_style_from_download_status(download_status: &str) -> Style {
    _ => style_success(),
  }
 }
+
+fn determine_style_from_rejection(rejected: bool) -> Style {
+  if rejected {
+    style_failure()
+  } else {
+    style_primary()
+  }
+}
+
+fn determine_peer_style(seeders: u64, leechers: u64) -> Style {
+  if seeders == 0 {
+    style_failure()
+  } else if seeders < leechers {
+    style_warning()
+  } else {
+    style_success()
+  }
+}