Full support for editing movies and managing tags

src/ui/radarr_ui/add_movie_ui.rs

@@ -31,7 +31,9 @@ pub(super) fn draw_add_movie_search_popup<B: Backend>(
 ) {
   if let Route::Radarr(active_radarr_block, context_option) = *app.get_current_route() {
     match active_radarr_block {
-      ActiveRadarrBlock::AddMovieSearchInput | ActiveRadarrBlock::AddMovieSearchResults => {
+      ActiveRadarrBlock::AddMovieSearchInput
+      | ActiveRadarrBlock::AddMovieSearchResults
+      | ActiveRadarrBlock::AddMovieEmptySearchResults => {
         draw_add_movie_search(f, app, area);
       }
       ActiveRadarrBlock::AddMoviePrompt
@@ -108,6 +110,10 @@ fn draw_add_movie_search<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area:
           .alignment(Alignment::Center);
         f.render_widget(help_paragraph, chunks[2]);
       }
+      ActiveRadarrBlock::AddMovieEmptySearchResults => {
+        f.render_widget(layout_block(), chunks[1]);
+        draw_error_popup(f, "No movies found matching your query!");
+      }
       ActiveRadarrBlock::AddMovieSearchResults
       | ActiveRadarrBlock::AddMoviePrompt
       | ActiveRadarrBlock::AddMovieSelectMonitor
@@ -122,99 +128,92 @@ fn draw_add_movie_search<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area:
           .alignment(Alignment::Center);
         f.render_widget(help_paragraph, chunks[2]);
 
-        if app.data.radarr_data.add_searched_movies.items.is_empty()
-          && !app.is_loading
-          && !app.is_routing
-        {
-          f.render_widget(layout_block(), chunks[1]);
-          draw_error_popup(f, "No movies found matching your query!");
-        } else {
-          draw_table(
-            f,
-            chunks[1],
-            layout_block(),
-            TableProps {
-              content: &mut app.data.radarr_data.add_searched_movies,
-              table_headers: vec![
-                "✔",
-                "Title",
-                "Year",
-                "Runtime",
-                "IMDB",
-                "Rotten Tomatoes",
-                "Genres",
-              ],
-              constraints: vec![
-                Constraint::Percentage(2),
-                Constraint::Percentage(27),
-                Constraint::Percentage(8),
-                Constraint::Percentage(10),
-                Constraint::Percentage(8),
-                Constraint::Percentage(14),
-                Constraint::Percentage(28),
-              ],
-              help: None,
-            },
-            |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)
-              };
-              let in_library = if app
-                .data
-                .radarr_data
-                .movies
-                .items
-                .iter()
-                .any(|mov| mov.tmdb_id == movie.tmdb_id)
-              {
-                "✔"
-              } else {
-                ""
-              };
+        draw_table(
+          f,
+          chunks[1],
+          layout_block(),
+          TableProps {
+            content: &mut app.data.radarr_data.add_searched_movies,
+            table_headers: vec![
+              "✔",
+              "Title",
+              "Year",
+              "Runtime",
+              "IMDB",
+              "Rotten Tomatoes",
+              "Genres",
+            ],
+            constraints: vec![
+              Constraint::Percentage(2),
+              Constraint::Percentage(27),
+              Constraint::Percentage(8),
+              Constraint::Percentage(10),
+              Constraint::Percentage(8),
+              Constraint::Percentage(14),
+              Constraint::Percentage(28),
+            ],
+            help: None,
+          },
+          |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)
+            };
+            let in_library = if app
+              .data
+              .radarr_data
+              .movies
+              .items
+              .iter()
+              .any(|mov| mov.tmdb_id == movie.tmdb_id)
+            {
+              "✔"
+            } else {
+              ""
+            };
 
-              movie.title.scroll_left_or_reset(
-                get_width_from_percentage(area, 27),
-                *movie == current_selection,
-              );
+            movie.title.scroll_left_or_reset(
+              get_width_from_percentage(area, 27),
+              *movie == current_selection,
+              app.tick_count % app.ticks_until_scroll == 0,
+            );
 
-              Row::new(vec![
-                Cell::from(in_library),
-                Cell::from(movie.title.to_string()),
-                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,
-          );
-        }
+            Row::new(vec![
+              Cell::from(in_library),
+              Cell::from(movie.title.to_string()),
+              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,
+        );
       }
       _ => (),
     }

src/ui/radarr_ui/collection_details_ui.rs

@@ -65,7 +65,7 @@ pub(super) fn draw_collection_details<B: Backend>(
     .data
     .radarr_data
     .quality_profile_map
-    .get(&collection_selection.quality_profile_id.as_u64().unwrap())
+    .get_by_left(&collection_selection.quality_profile_id.as_u64().unwrap())
     .unwrap()
     .to_owned();
   let current_selection = if app.data.radarr_data.collection_movies.items.is_empty() {
@@ -155,6 +155,7 @@ pub(super) fn draw_collection_details<B: Backend>(
       movie.title.scroll_left_or_reset(
         get_width_from_percentage(chunks[1], 20),
         current_selection == *movie,
+        app.tick_count % app.ticks_until_scroll == 0,
       );
       let (hours, minutes) = convert_runtime(movie.runtime.as_u64().unwrap());
       let imdb_rating = movie

src/ui/radarr_ui/mod.rs

@@ -210,7 +210,7 @@ fn draw_library<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect) {
       let file_size: f64 = convert_to_gb(movie.size_on_disk.as_u64().unwrap());
       let certification = movie.certification.clone().unwrap_or_else(|| "".to_owned());
       let quality_profile = quality_profile_map
-        .get(&movie.quality_profile_id.as_u64().unwrap())
+        .get_by_left(&movie.quality_profile_id.as_u64().unwrap())
         .unwrap()
         .to_owned();
       let tags = movie
@@ -475,6 +475,7 @@ fn draw_downloads<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect) {
       path.scroll_left_or_reset(
         get_width_from_percentage(area, 18),
         current_selection == *download_record,
+        app.tick_count % app.ticks_until_scroll == 0,
       );
 
       let percent = 1f64 - (sizeleft.as_f64().unwrap() / size.as_f64().unwrap());
@@ -533,7 +534,7 @@ fn draw_collections<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect)
         Cell::from(collection.root_folder_path.clone().unwrap_or_default()),
         Cell::from(
           quality_profile_map
-            .get(&collection.quality_profile_id.as_u64().unwrap())
+            .get_by_left(&collection.quality_profile_id.as_u64().unwrap())
             .unwrap()
             .to_owned(),
         ),

src/ui/radarr_ui/movie_details_ui.rs

@@ -271,6 +271,7 @@ fn draw_movie_history<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, content_a
         movie_history_item.source_title.scroll_left_or_reset(
           get_width_from_percentage(content_area, 34),
           current_selection == *movie_history_item,
+          app.tick_count % app.ticks_until_scroll == 0,
         );
 
         Row::new(vec![
@@ -322,7 +323,7 @@ fn draw_movie_cast<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, content_area
       .style(style_success())
     },
     app.is_loading,
-  )
+  );
 }
 
 fn draw_movie_crew<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, content_area: Rect) {
@@ -442,6 +443,7 @@ fn draw_movie_releases<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, content_
         get_width_from_percentage(content_area, 30),
         current_selection == *release
           && current_route != ActiveRadarrBlock::ManualSearchConfirmPrompt.into(),
+        app.tick_count % app.ticks_until_scroll == 0,
       );
       let size = convert_to_gb(size.as_u64().unwrap());
       let rejected_str = if *rejected { "⛔" } else { "" };
@@ -477,7 +479,7 @@ fn draw_movie_releases<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, content_
       .style(style_primary())
     },
     app.is_loading,
-  )
+  );
 }
 
 fn draw_manual_search_confirm_prompt<B: Backend>(