Successful implementation of movie adding and deleting, and refactored network logic to be more reusable later

README.md

@@ -81,7 +81,7 @@ tautulli:
 - [x] View details of a specific movie including description, history, downloaded file info, or the credits
 - [x] View details of any collection and the movies in them
 - [x] Search your library or collections
-- [ ] Add or delete movies
+- [x] Add or delete movies
 - [ ] Manage your quality profiles
 - [ ] Modify your Radarr settings
 

src/app/radarr.rs

@@ -7,12 +7,13 @@ use strum::EnumIter;
 use crate::app::{App, Route};
 use crate::models::radarr_models::{
   AddMovieSearchResult, Collection, CollectionMovie, Credit, DiskSpace, DownloadRecord, Movie,
-  MovieHistoryItem,
+  MovieHistoryItem, RootFolder,
 };
 use crate::models::{ScrollableText, StatefulTable, TabRoute, TabState};
 use crate::network::radarr_network::RadarrEvent;
 
 pub struct RadarrData {
+  pub root_folders: Vec<RootFolder>,
   pub disk_space_vec: Vec<DiskSpace>,
   pub version: String,
   pub start_time: DateTime<Utc>,
@@ -31,6 +32,7 @@ pub struct RadarrData {
   pub collections: StatefulTable<Collection>,
   pub filtered_collections: StatefulTable<Collection>,
   pub collection_movies: StatefulTable<CollectionMovie>,
+  pub prompt_confirm_action: Option<RadarrEvent>,
   pub main_tabs: TabState,
   pub movie_info_tabs: TabState,
   pub search: String,
@@ -72,6 +74,7 @@ impl RadarrData {
 impl Default for RadarrData {
   fn default() -> RadarrData {
     RadarrData {
+      root_folders: Vec::new(),
       disk_space_vec: Vec::new(),
       version: String::default(),
       start_time: DateTime::default(),
@@ -90,6 +93,7 @@ impl Default for RadarrData {
       collections: StatefulTable::default(),
       filtered_collections: StatefulTable::default(),
       collection_movies: StatefulTable::default(),
+      prompt_confirm_action: None,
       search: String::default(),
       filter: String::default(),
       is_searching: false,
@@ -201,19 +205,15 @@ impl App {
         self
           .dispatch_network_event(RadarrEvent::GetDownloads.into())
           .await;
-
+        self.check_for_prompt_action().await;
-        if self.data.radarr_data.prompt_confirm {
-          self.data.radarr_data.prompt_confirm = false;
-          self
-            .dispatch_network_event(RadarrEvent::DeleteMovie.into())
-            .await;
-        }
       }
       ActiveRadarrBlock::AddMovieSearchResults => {
         self.is_loading = true;
         self
           .dispatch_network_event(RadarrEvent::SearchNewMovie.into())
           .await;
+
+        self.check_for_prompt_action().await;
       }
       ActiveRadarrBlock::MovieDetails | ActiveRadarrBlock::FileInfo => {
         self.is_loading = true;
@@ -243,6 +243,19 @@ impl App {
     self.reset_tick_count();
   }
 
+  async fn check_for_prompt_action(&mut self) {
+    if self.data.radarr_data.prompt_confirm {
+      self.data.radarr_data.prompt_confirm = false;
+      if let Some(radarr_event) = &self.data.radarr_data.prompt_confirm_action {
+        self
+          .dispatch_network_event(radarr_event.clone().into())
+          .await;
+        self.should_refresh = true;
+        self.data.radarr_data.prompt_confirm_action = None;
+      }
+    }
+  }
+
   pub(super) async fn radarr_on_tick(
     &mut self,
     active_radarr_block: ActiveRadarrBlock,
@@ -252,6 +265,9 @@ impl App {
       self
         .dispatch_network_event(RadarrEvent::GetQualityProfiles.into())
         .await;
+      self
+        .dispatch_network_event(RadarrEvent::GetRootFolders.into())
+        .await;
       self
         .dispatch_network_event(RadarrEvent::GetOverview.into())
         .await;

src/handlers/mod.rs

@@ -43,16 +43,22 @@ pub trait KeyEventHandler<'a, T: Into<Route>> {
 }
 
 pub fn handle_events(key: Key, app: &mut App) {
-  match app.get_current_route().clone() {
+  if let Route::Radarr(active_radarr_block) = app.get_current_route().clone() {
-    Route::Radarr(active_radarr_block) => {
     RadarrHandler::with(&key, app, &active_radarr_block).handle()
   }
-    _ => (),
-  }
 }
 
-pub fn handle_clear_errors(app: &mut App) {
+fn handle_clear_errors(app: &mut App) {
   if !app.error.text.is_empty() {
     app.error = HorizontallyScrollableText::default();
   }
 }
+
+fn handle_prompt_toggle(app: &mut App, key: &Key) {
+  match key {
+    _ if *key == DEFAULT_KEYBINDINGS.left.key || *key == DEFAULT_KEYBINDINGS.right.key => {
+      app.data.radarr_data.prompt_confirm = !app.data.radarr_data.prompt_confirm;
+    }
+    _ => (),
+  }
+}

src/handlers/radarr_handlers/add_movie_handler.rs

@@ -1,7 +1,8 @@
 use crate::app::key_binding::DEFAULT_KEYBINDINGS;
 use crate::app::radarr::ActiveRadarrBlock;
-use crate::handlers::KeyEventHandler;
+use crate::handlers::{handle_prompt_toggle, KeyEventHandler};
 use crate::models::{Scrollable, StatefulTable};
+use crate::network::radarr_network::RadarrEvent;
 use crate::{App, Key};
 
 pub(super) struct AddMovieHandler<'a> {
@@ -28,44 +29,36 @@ impl<'a> KeyEventHandler<'a, ActiveRadarrBlock> for AddMovieHandler<'a> {
   }
 
   fn handle_scroll_up(&mut self) {
-    match self.active_radarr_block {
+    if self.active_radarr_block == &ActiveRadarrBlock::AddMovieSearchResults {
-      ActiveRadarrBlock::AddMovieSearchResults => {
       self.app.data.radarr_data.add_searched_movies.scroll_up()
     }
-      _ => (),
-    }
   }
 
   fn handle_scroll_down(&mut self) {
-    match self.active_radarr_block {
+    if self.active_radarr_block == &ActiveRadarrBlock::AddMovieSearchResults {
-      ActiveRadarrBlock::AddMovieSearchResults => {
       self.app.data.radarr_data.add_searched_movies.scroll_down()
     }
-      _ => (),
-    }
   }
 
   fn handle_home(&mut self) {
-    match self.active_radarr_block {
+    if self.active_radarr_block == &ActiveRadarrBlock::AddMovieSearchResults {
-      ActiveRadarrBlock::AddMovieSearchResults => self
+      self
         .app
         .data
         .radarr_data
         .add_searched_movies
-        .scroll_to_top(),
+        .scroll_to_top()
-      _ => (),
     }
   }
 
   fn handle_end(&mut self) {
-    match self.active_radarr_block {
+    if self.active_radarr_block == &ActiveRadarrBlock::AddMovieSearchResults {
-      ActiveRadarrBlock::AddMovieSearchResults => self
+      self
         .app
         .data
         .radarr_data
         .add_searched_movies
-        .scroll_to_bottom(),
+        .scroll_to_bottom()
-      _ => (),
     }
   }
 
@@ -73,14 +66,7 @@ impl<'a> KeyEventHandler<'a, ActiveRadarrBlock> for AddMovieHandler<'a> {
 
   fn handle_left_right_action(&mut self) {
     if *self.active_radarr_block == ActiveRadarrBlock::AddMoviePrompt {
-      match self.key {
+      handle_prompt_toggle(self.app, self.key);
-        _ if *self.key == DEFAULT_KEYBINDINGS.left.key
-          || *self.key == DEFAULT_KEYBINDINGS.right.key =>
-        {
-          self.app.data.radarr_data.prompt_confirm = !self.app.data.radarr_data.prompt_confirm;
-        }
-        _ => (),
-      }
     }
   }
 
@@ -97,6 +83,14 @@ impl<'a> KeyEventHandler<'a, ActiveRadarrBlock> for AddMovieHandler<'a> {
           .app
           .push_navigation_stack(ActiveRadarrBlock::AddMoviePrompt.into());
       }
+      ActiveRadarrBlock::AddMoviePrompt => {
+        if self.app.data.radarr_data.prompt_confirm {
+          self.app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::AddMovie);
+          self.app.pop_navigation_stack();
+        } else {
+          self.app.pop_navigation_stack();
+        }
+      }
       _ => (),
     }
   }
@@ -123,8 +117,8 @@ impl<'a> KeyEventHandler<'a, ActiveRadarrBlock> for AddMovieHandler<'a> {
 
   fn handle_char_key_event(&mut self) {
     let key = self.key;
-    match self.active_radarr_block {
+    if self.active_radarr_block == &ActiveRadarrBlock::AddMovieSearchInput {
-      ActiveRadarrBlock::AddMovieSearchInput => match self.key {
+      match self.key {
         _ if *key == DEFAULT_KEYBINDINGS.backspace.key => {
           self.app.data.radarr_data.search.pop();
         }
@@ -132,8 +126,7 @@ impl<'a> KeyEventHandler<'a, ActiveRadarrBlock> for AddMovieHandler<'a> {
           self.app.data.radarr_data.search.push(*character);
         }
         _ => (),
-      },
+      }
-      _ => (),
     }
   }
 }

src/handlers/radarr_handlers/mod.rs

@@ -3,8 +3,9 @@ use crate::app::radarr::ActiveRadarrBlock;
 use crate::handlers::radarr_handlers::add_movie_handler::AddMovieHandler;
 use crate::handlers::radarr_handlers::collection_details_handler::CollectionDetailsHandler;
 use crate::handlers::radarr_handlers::movie_details_handler::MovieDetailsHandler;
-use crate::handlers::{handle_clear_errors, KeyEventHandler};
+use crate::handlers::{handle_clear_errors, handle_prompt_toggle, KeyEventHandler};
 use crate::models::Scrollable;
+use crate::network::radarr_network::RadarrEvent;
 use crate::utils::strip_non_alphanumeric_characters;
 use crate::{App, Key};
 
@@ -217,14 +218,7 @@ impl<'a> KeyEventHandler<'a, ActiveRadarrBlock> for RadarrHandler<'a> {
           _ => (),
         }
       }
-      ActiveRadarrBlock::DeleteMoviePrompt => match self.key {
+      ActiveRadarrBlock::DeleteMoviePrompt => handle_prompt_toggle(self.app, self.key),
-        _ if *self.key == DEFAULT_KEYBINDINGS.left.key
-          || *self.key == DEFAULT_KEYBINDINGS.right.key =>
-        {
-          self.app.data.radarr_data.prompt_confirm = !self.app.data.radarr_data.prompt_confirm;
-        }
-        _ => (),
-      },
       _ => (),
     }
   }
@@ -292,7 +286,10 @@ impl<'a> KeyEventHandler<'a, ActiveRadarrBlock> for RadarrHandler<'a> {
         }
       }
       ActiveRadarrBlock::DeleteMoviePrompt => {
-        self.app.should_refresh = self.app.data.radarr_data.prompt_confirm;
+        if self.app.data.radarr_data.prompt_confirm {
+          self.app.data.radarr_data.prompt_confirm_action = Some(RadarrEvent::DeleteMovie);
+        }
+
         self.app.pop_navigation_stack();
       }
       _ => (),

src/models/radarr_models.rs

@@ -19,6 +19,14 @@ pub struct SystemStatus {
   pub start_time: DateTime<Utc>,
 }
 
+#[derive(Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct RootFolder {
+  pub path: String,
+  pub accessible: bool,
+  pub free_space: Number,
+}
+
 #[derive(Derivative, Deserialize, Debug, Clone, PartialEq, Eq)]
 #[derivative(Default)]
 #[serde(rename_all = "camelCase")]
@@ -200,19 +208,19 @@ pub struct Credit {
   pub credit_type: CreditType,
 }
 
-#[derive(Serialize, Debug)]
+#[derive(Default, Derivative, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct AddMovieBody {
-  pub tmdb_id: Number,
+  pub tmdb_id: u64,
   pub title: String,
   pub root_folder_path: String,
-  pub quality_profile_id: Number,
+  pub quality_profile_id: u64,
   pub minimum_availability: String,
   pub monitored: bool,
   pub add_options: AddOptions,
 }
 
-#[derive(Serialize, Debug, PartialEq, Eq)]
+#[derive(Default, Serialize, Debug, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct AddOptions {
   pub search_for_movie: bool,

src/network/mod.rs

@@ -1,7 +1,12 @@
+use std::fmt::Debug;
 use std::sync::Arc;
 
-use reqwest::Client;
+use anyhow::anyhow;
-use tokio::sync::Mutex;
+use log::{debug, error};
+use reqwest::{Client, RequestBuilder};
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+use tokio::sync::{Mutex, MutexGuard};
 
 use crate::app::App;
 use crate::network::radarr_network::RadarrEvent;
@@ -33,4 +38,90 @@ impl<'a> Network<'a> {
     let mut app = self.app.lock().await;
     app.is_loading = false;
   }
+
+  pub async fn handle_request<T, R>(
+    &self,
+    request_props: RequestProps<T>,
+    mut app_update_fn: impl FnMut(R, MutexGuard<App>),
+  ) where
+    T: Serialize + Default + Debug,
+    R: DeserializeOwned,
+  {
+    let method = request_props.method.clone();
+    match self.call_api(request_props).await.send().await {
+      Ok(response) => {
+        if response.status().is_success() {
+          match method {
+            RequestMethod::Get => match utils::parse_response::<R>(response).await {
+              Ok(value) => {
+                let app = self.app.lock().await;
+                app_update_fn(value, app);
+              }
+              Err(e) => {
+                error!("Failed to parse response! {:?}", e);
+                self.app.lock().await.handle_error(anyhow!(e));
+              }
+            },
+            RequestMethod::Delete | RequestMethod::Post => (),
+          }
+        } else {
+          error!(
+            "Request failed. Received {} response code",
+            response.status()
+          );
+          self.app.lock().await.handle_error(anyhow!(
+            "Request failed. Received {} response code",
+            response.status()
+          ));
+        }
+      }
+      Err(e) => {
+        error!("Failed to send request. {:?}", e);
+        self.app.lock().await.handle_error(anyhow!(e));
+      }
+    }
+  }
+
+  async fn call_api<T: Serialize + Default + Debug>(
+    &self,
+    request_props: RequestProps<T>,
+  ) -> RequestBuilder {
+    let RequestProps {
+      uri,
+      method,
+      body,
+      api_token,
+    } = request_props;
+    debug!("Creating RequestBuilder for resource: {:?}", uri);
+    let app = self.app.lock().await;
+    debug!(
+      "Sending {:?} request to {} with body {:?}",
+      method, uri, body
+    );
+
+    match method {
+      RequestMethod::Get => app.client.get(uri).header("X-Api-Key", api_token),
+      RequestMethod::Post => app
+        .client
+        .post(uri)
+        .json(&body.unwrap_or_default())
+        .header("X-Api-Key", api_token),
+      RequestMethod::Delete => app.client.delete(uri).header("X-Api-Key", api_token),
+    }
+  }
+}
+
+#[derive(Clone, Debug)]
+pub enum RequestMethod {
+  Get,
+  Post,
+  Delete,
+}
+
+#[derive(Debug)]
+pub struct RequestProps<T: Serialize + Debug> {
+  pub uri: String,
+  pub method: RequestMethod,
+  pub body: Option<T>,
+  pub api_token: String,
 }

src/network/radarr_network.rs

@@ -1,23 +1,23 @@
-use anyhow::anyhow;
+use std::fmt::Debug;
+
 use indoc::formatdoc;
-use log::{debug, error};
+use log::{debug, info};
-use reqwest::{RequestBuilder, StatusCode};
+use serde::Serialize;
-use serde::de::DeserializeOwned;
-use tokio::sync::MutexGuard;
 use urlencoding::encode;
 
-use crate::app::{App, RadarrConfig};
+use crate::app::RadarrConfig;
 use crate::models::radarr_models::{
-  AddMovieSearchResult, Collection, Credit, CreditType, DiskSpace, DownloadsResponse, Movie,
+  AddMovieBody, AddMovieSearchResult, AddOptions, Collection, Credit, CreditType, DiskSpace,
-  MovieHistoryItem, QualityProfile, SystemStatus,
+  DownloadsResponse, Movie, MovieHistoryItem, QualityProfile, RootFolder, SystemStatus,
 };
 use crate::models::ScrollableText;
 use crate::network::utils::get_movie_status;
-use crate::network::{utils, Network, NetworkEvent};
+use crate::network::{Network, NetworkEvent, RequestMethod, RequestProps};
 use crate::utils::{convert_runtime, convert_to_gb};
 
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Debug, Eq, PartialEq, Clone)]
 pub enum RadarrEvent {
+  AddMovie,
   DeleteMovie,
   GetCollections,
   GetDownloads,
@@ -27,34 +27,27 @@ pub enum RadarrEvent {
   GetMovieHistory,
   GetOverview,
   GetQualityProfiles,
+  GetRootFolders,
   GetStatus,
   SearchNewMovie,
   HealthCheck,
 }
 
-#[derive(Clone)]
-enum RequestMethod {
-  GET,
-  DELETE,
-}
-
-struct RequestProps<T> {
-  pub resource: String,
-  pub method: RequestMethod,
-  pub body: Option<T>,
-}
-
 impl RadarrEvent {
   const fn resource(self) -> &'static str {
     match self {
       RadarrEvent::GetCollections => "/collection",
       RadarrEvent::GetDownloads => "/queue",
-      RadarrEvent::GetMovies | RadarrEvent::GetMovieDetails | RadarrEvent::DeleteMovie => "/movie",
+      RadarrEvent::AddMovie
+      | RadarrEvent::GetMovies
+      | RadarrEvent::GetMovieDetails
+      | RadarrEvent::DeleteMovie => "/movie",
       RadarrEvent::SearchNewMovie => "/movie/lookup",
       RadarrEvent::GetMovieCredits => "/credit",
       RadarrEvent::GetMovieHistory => "/history/movie",
       RadarrEvent::GetOverview => "/diskspace",
       RadarrEvent::GetQualityProfiles => "/qualityprofile",
+      RadarrEvent::GetRootFolders => "/rootfolder",
       RadarrEvent::GetStatus => "/system/status",
       RadarrEvent::HealthCheck => "/health",
     }
@@ -70,166 +63,136 @@ impl From<RadarrEvent> for NetworkEvent {
 impl<'a> Network<'a> {
   pub async fn handle_radarr_event(&self, radarr_event: RadarrEvent) {
     match radarr_event {
-      RadarrEvent::GetCollections => {
+      RadarrEvent::GetCollections => self.get_collections().await,
-        self
+      RadarrEvent::HealthCheck => self.get_healthcheck().await,
-          .get_collections(RadarrEvent::GetCollections.resource().to_owned())
+      RadarrEvent::GetOverview => self.get_diskspace().await,
-          .await
+      RadarrEvent::GetStatus => self.get_status().await,
-      }
+      RadarrEvent::GetMovies => self.get_movies().await,
-      RadarrEvent::HealthCheck => {
+      RadarrEvent::DeleteMovie => self.delete_movie().await,
-        self
+      RadarrEvent::GetMovieCredits => self.get_credits().await,
-          .get_healthcheck(RadarrEvent::HealthCheck.resource().to_owned())
+      RadarrEvent::GetMovieDetails => self.get_movie_details().await,
-          .await
+      RadarrEvent::GetMovieHistory => self.get_movie_history().await,
-      }
+      RadarrEvent::GetDownloads => self.get_downloads().await,
-      RadarrEvent::GetOverview => {
+      RadarrEvent::GetQualityProfiles => self.get_quality_profiles().await,
-        self
+      RadarrEvent::GetRootFolders => self.get_root_folders().await,
-          .get_diskspace(RadarrEvent::GetOverview.resource().to_owned())
+      RadarrEvent::SearchNewMovie => self.search_movie().await,
-          .await
+      RadarrEvent::AddMovie => self.add_movie().await,
-      }
-      RadarrEvent::GetStatus => {
-        self
-          .get_status(RadarrEvent::GetStatus.resource().to_owned())
-          .await
-      }
-      RadarrEvent::GetMovies => {
-        self
-          .get_movies(RadarrEvent::GetMovies.resource().to_owned())
-          .await
-      }
-      RadarrEvent::DeleteMovie => {
-        self
-          .delete_movie(RadarrEvent::DeleteMovie.resource().to_owned())
-          .await
-      }
-      RadarrEvent::GetMovieCredits => {
-        self
-          .get_credits(RadarrEvent::GetMovieCredits.resource().to_owned())
-          .await
-      }
-      RadarrEvent::GetMovieDetails => {
-        self
-          .get_movie_details(RadarrEvent::GetMovieDetails.resource().to_owned())
-          .await
-      }
-      RadarrEvent::GetMovieHistory => {
-        self
-          .get_movie_history(RadarrEvent::GetMovieHistory.resource().to_owned())
-          .await
-      }
-      RadarrEvent::GetDownloads => {
-        self
-          .get_downloads(RadarrEvent::GetDownloads.resource().to_owned())
-          .await
-      }
-      RadarrEvent::GetQualityProfiles => {
-        self
-          .get_quality_profiles(RadarrEvent::GetQualityProfiles.resource().to_owned())
-          .await
-      }
-      RadarrEvent::SearchNewMovie => {
-        self
-          .search_movie(RadarrEvent::SearchNewMovie.resource().to_owned())
-          .await
-      }
-    }
-  }
-
-  async fn get_healthcheck(&self, resource: String) {
-    if let Err(e) = self
-      .call_radarr_api::<()>(RequestProps {
-        resource,
-        method: RequestMethod::GET,
-        body: None::<()>,
-      })
-      .await
-      .send()
-      .await
-    {
-      error!("Healthcheck failed. {:?}", e);
-      self.app.lock().await.handle_error(anyhow!(e));
     }
   }
 
-  async fn get_diskspace(&self, resource: String) {
+  async fn get_healthcheck(&self) {
-    type ResponseType = Vec<DiskSpace>;
+    info!("Performing Radarr health check");
-    self
+
-      .handle_request::<ResponseType>(
+    let request_props = self
-        RequestProps {
+      .radarr_request_props_from(
-          resource,
+        RadarrEvent::HealthCheck.resource(),
-          method: RequestMethod::GET,
+        RequestMethod::Get,
-          body: None::<ResponseType>,
+        None::<()>,
-        },
-        |disk_space_vec, mut app| {
-          app.data.radarr_data.disk_space_vec = disk_space_vec;
-        },
       )
       .await;
+
+    self
+      .handle_request::<(), ()>(request_props, |_, _| ())
+      .await;
   }
 
-  async fn get_status(&self, resource: String) {
+  async fn get_diskspace(&self) {
+    info!("Fetching Radarr disk space");
+
+    let request_props = self
+      .radarr_request_props_from(
+        RadarrEvent::GetOverview.resource(),
+        RequestMethod::Get,
+        None::<()>,
+      )
+      .await;
+
     self
-      .handle_request::<SystemStatus>(
+      .handle_request::<(), Vec<DiskSpace>>(request_props, |disk_space_vec, mut app| {
-        RequestProps {
+        app.data.radarr_data.disk_space_vec = disk_space_vec;
-          resource,
+      })
-          method: RequestMethod::GET,
+      .await;
-          body: None::<SystemStatus>,
+  }
-        },
+
-        |system_status, mut app| {
+  async fn get_status(&self) {
+    info!("Fetching Radarr system status");
+
+    let request_props = self
+      .radarr_request_props_from(
+        RadarrEvent::GetStatus.resource(),
+        RequestMethod::Get,
+        None::<()>,
+      )
+      .await;
+
+    self
+      .handle_request::<(), SystemStatus>(request_props, |system_status, mut app| {
         app.data.radarr_data.version = system_status.version;
         app.data.radarr_data.start_time = system_status.start_time;
-        },
+      })
-      )
       .await;
   }
 
-  async fn get_movies(&self, resource: String) {
+  async fn get_movies(&self) {
-    type ResponseType = Vec<Movie>;
+    info!("Fetching Radarr library");
+
+    let request_props = self
+      .radarr_request_props_from(
+        RadarrEvent::GetMovies.resource(),
+        RequestMethod::Get,
+        None::<()>,
+      )
+      .await;
+
     self
-      .handle_request::<ResponseType>(
+      .handle_request::<(), Vec<Movie>>(request_props, |movie_vec, mut app| {
-        RequestProps {
+        app.data.radarr_data.movies.set_items(movie_vec)
-          resource,
+      })
-          method: RequestMethod::GET,
-          body: None::<ResponseType>,
-        },
-        |movie_vec, mut app| app.data.radarr_data.movies.set_items(movie_vec),
-      )
       .await;
   }
 
-  async fn search_movie(&self, resource: String) {
+  async fn search_movie(&self) {
-    type ResponseType = Vec<AddMovieSearchResult>;
+    info!("Searching for specific Radarr movie");
+
     let search_string = self.app.lock().await.data.radarr_data.search.clone();
-    debug!(
+    let request_props = self
-      "Searching for movie: {:?}",
+      .radarr_request_props_from(
-      format!("{}?term={}", resource, encode(search_string.as_str()))
+        format!(
-    );
+          "{}?term={}",
+          RadarrEvent::SearchNewMovie.resource(),
+          encode(&search_string)
+        )
+        .as_str(),
+        RequestMethod::Get,
+        None::<()>,
+      )
+      .await;
+
     self
-      .handle_request::<ResponseType>(
+      .handle_request::<(), Vec<AddMovieSearchResult>>(request_props, |movie_vec, mut app| {
-        RequestProps {
-          resource: format!("{}?term={}", resource, encode(&search_string)),
-          method: RequestMethod::GET,
-          body: None::<ResponseType>,
-        },
-        |movie_vec, mut app| {
         app
           .data
           .radarr_data
           .add_searched_movies
           .set_items(movie_vec)
-        },
+      })
-      )
       .await;
   }
 
-  async fn get_movie_details(&self, resource: String) {
+  async fn get_movie_details(&self) {
+    info!("Fetching Radarr movie details");
+
     let movie_id = self.extract_movie_id().await;
+    let request_props = self
+      .radarr_request_props_from(
+        format!("{}/{}", RadarrEvent::GetMovieDetails.resource(), movie_id).as_str(),
+        RequestMethod::Get,
+        None::<()>,
+      )
+      .await;
+
     self
-      .handle_request::<Movie>(
+      .handle_request::<(), Movie>(request_props, |movie_response, mut app| {
-        RequestProps {
-          resource: format!("{}/{}", resource, movie_id),
-          method: RequestMethod::GET,
-          body: None::<Movie>,
-        },
-        |movie_response, mut app| {
         let Movie {
           id,
           title,
@@ -365,21 +328,26 @@ impl<'a> Network<'a> {
             media_info.run_time
           );
         }
-        },
+      })
-      )
       .await;
   }
 
-  async fn get_movie_history(&self, resource: String) {
+  async fn get_movie_history(&self) {
-    type ResponseType = Vec<MovieHistoryItem>;
+    info!("Fetching Radarr movie history");
+
+    let request_props = self
+      .radarr_request_props_from(
         self
-      .handle_request::<ResponseType>(
+          .append_movie_id_param(RadarrEvent::GetMovieHistory.resource())
-        RequestProps {
+          .await
-          resource: self.append_movie_id_param(&resource).await,
+          .as_str(),
-          method: RequestMethod::GET,
+        RequestMethod::Get,
-          body: None::<ResponseType>,
+        None::<()>,
-        },
+      )
-        |movie_history_vec, mut app| {
+      .await;
+
+    self
+      .handle_request::<(), Vec<MovieHistoryItem>>(request_props, |movie_history_vec, mut app| {
         let mut reversed_movie_history_vec = movie_history_vec.to_vec();
         reversed_movie_history_vec.reverse();
         app
@@ -387,75 +355,105 @@ impl<'a> Network<'a> {
           .radarr_data
           .movie_history
           .set_items(reversed_movie_history_vec)
-        },
+      })
-      )
       .await;
   }
 
-  async fn get_collections(&self, resource: String) {
+  async fn get_collections(&self) {
-    type ResponseType = Vec<Collection>;
+    info!("Fetching Radarr collections");
+
+    let request_props = self
+      .radarr_request_props_from(
+        RadarrEvent::GetCollections.resource(),
+        RequestMethod::Get,
+        None::<()>,
+      )
+      .await;
+
     self
-      .handle_request::<ResponseType>(
+      .handle_request::<(), Vec<Collection>>(request_props, |collections_vec, mut app| {
-        RequestProps {
-          resource,
-          method: RequestMethod::GET,
-          body: None::<ResponseType>,
-        },
-        |collections_vec, mut app| {
         app.data.radarr_data.collections.set_items(collections_vec);
-        },
+      })
-      )
       .await;
   }
 
-  async fn get_downloads(&self, resource: String) {
+  async fn get_downloads(&self) {
+    info!("Fetching Radarr downloads");
+
+    let request_props = self
+      .radarr_request_props_from(
+        RadarrEvent::GetDownloads.resource(),
+        RequestMethod::Get,
+        None::<()>,
+      )
+      .await;
+
     self
-      .handle_request::<DownloadsResponse>(
+      .handle_request::<(), DownloadsResponse>(request_props, |queue_response, mut app| {
-        RequestProps {
-          resource,
-          method: RequestMethod::GET,
-          body: None::<DownloadsResponse>,
-        },
-        |queue_response, mut app| {
         app
           .data
           .radarr_data
           .downloads
           .set_items(queue_response.records);
-        },
+      })
-      )
       .await
   }
 
-  async fn get_quality_profiles(&self, resource: String) {
+  async fn get_quality_profiles(&self) {
-    type ResponseType = Vec<QualityProfile>;
+    info!("Fetching Radarr quality profiles");
+
+    let request_props = self
+      .radarr_request_props_from(
+        RadarrEvent::GetQualityProfiles.resource(),
+        RequestMethod::Get,
+        None::<()>,
+      )
+      .await;
+
     self
-      .handle_request::<ResponseType>(
+      .handle_request::<(), Vec<QualityProfile>>(request_props, |quality_profiles, mut app| {
-        RequestProps {
-          resource,
-          method: RequestMethod::GET,
-          body: None::<ResponseType>,
-        },
-        |quality_profiles, mut app| {
         app.data.radarr_data.quality_profile_map = quality_profiles
           .iter()
           .map(|profile| (profile.id.as_u64().unwrap(), profile.name.clone()))
           .collect();
-        },
+      })
-      )
       .await;
   }
 
-  async fn get_credits(&self, resource: String) {
+  async fn get_root_folders(&self) {
-    type ResponseType = Vec<Credit>;
+    info!("Fetching Radarr root folders");
+
+    let request_props = self
+      .radarr_request_props_from(
+        RadarrEvent::GetRootFolders.resource(),
+        RequestMethod::Get,
+        None::<()>,
+      )
+      .await;
+
     self
-      .handle_request::<ResponseType>(
+      .handle_request::<(), Vec<RootFolder>>(request_props, |root_folders, mut app| {
-        RequestProps {
+        app.data.radarr_data.root_folders = root_folders;
-          resource: self.append_movie_id_param(&resource).await,
+      })
-          method: RequestMethod::GET,
+      .await;
-          body: None::<ResponseType>,
+  }
-        },
+
-        |credit_vec, mut app| {
+  async fn get_credits(&self) {
+    info!("Fetching Radarr movie credits");
+
+    let request_props = self
+      .radarr_request_props_from(
+        self
+          .append_movie_id_param(RadarrEvent::GetMovieCredits.resource())
+          .await
+          .as_str(),
+        RequestMethod::Get,
+        None::<()>,
+      )
+      .await;
+
+    self
+      .handle_request::<(), Vec<Credit>>(request_props, |credit_vec, mut app| {
         let cast_vec: Vec<Credit> = credit_vec
           .iter()
           .cloned()
@@ -469,88 +467,92 @@ impl<'a> Network<'a> {
 
         app.data.radarr_data.movie_cast.set_items(cast_vec);
         app.data.radarr_data.movie_crew.set_items(crew_vec);
-        },
+      })
-      )
       .await;
   }
 
-  async fn delete_movie(&self, resource: String) {
+  async fn delete_movie(&self) {
     let movie_id = self.extract_movie_id().await;
-    self
+
-      .handle_request::<()>(
+    info!("Deleting Radarr movie with id: {}", movie_id);
-        RequestProps {
+
-          resource: format!("{}/{}", resource, movie_id),
+    let request_props = self
-          method: RequestMethod::DELETE,
+      .radarr_request_props_from(
-          body: None::<()>,
+        format!("{}/{}", RadarrEvent::DeleteMovie.resource(), movie_id).as_str(),
-        },
+        RequestMethod::Delete,
-        |_, _| (),
+        None::<()>,
       )
       .await;
+
+    self
+      .handle_request::<(), ()>(request_props, |_, _| ())
+      .await;
   }
 
-  async fn call_radarr_api<T>(&self, request_props: RequestProps<T>) -> RequestBuilder {
+  async fn add_movie(&self) {
-    let RequestProps {
+    info!("Adding new movie to Radarr");
-      resource,
+    let root_folders = self.app.lock().await.data.radarr_data.root_folders.to_vec();
-      method,
+    let current_selection = self
-      body,
+      .app
-    } = request_props;
+      .lock()
-    debug!("Creating RequestBuilder for resource: {:?}", resource);
+      .await
-    let app = self.app.lock().await;
+      .data
-    let RadarrConfig {
+      .radarr_data
-      host,
+      .add_searched_movies
-      port,
+      .current_selection_clone();
-      api_token,
+    let quality_profile_map = self
-    } = &app.config.radarr;
+      .app
-    let uri = format!(
+      .lock()
-      "http://{}:{}/api/v3{}",
+      .await
-      host,
+      .data
-      port.unwrap_or(7878),
+      .radarr_data
-      resource
+      .quality_profile_map
-    );
+      .clone();
 
-    match method {
+    let RootFolder { path, .. } = root_folders
-      RequestMethod::GET => app.client.get(uri).header("X-Api-Key", api_token),
+      .iter()
-      RequestMethod::DELETE => app.client.delete(uri).header("X-Api-Key", api_token),
+      .filter(|folder| folder.accessible)
-    }
+      .reduce(|a, b| {
+        if a.free_space.as_u64().unwrap() > b.free_space.as_u64().unwrap() {
+          a
+        } else {
+          b
         }
+      })
+      .unwrap();
+    let AddMovieSearchResult { tmdb_id, title, .. } = current_selection;
+    let quality_profile_id = quality_profile_map
+      .iter()
+      .filter(|(_, value)| value.to_lowercase() == "any")
+      .map(|(key, _)| key)
+      .next()
+      .unwrap();
 
-  async fn handle_request<T>(
+    let body = AddMovieBody {
-    &self,
+      tmdb_id: tmdb_id.as_u64().unwrap(),
-    request_props: RequestProps<T>,
+      title: title.to_owned(),
-    mut app_update_fn: impl FnMut(T, MutexGuard<App>),
+      root_folder_path: path.to_owned(),
-  ) where
+      minimum_availability: "released".to_owned(),
-    T: DeserializeOwned,
+      monitored: true,
-  {
+      quality_profile_id: *quality_profile_id,
-    let method = request_props.method.clone();
+      add_options: AddOptions {
-    match self.call_radarr_api(request_props).await.send().await {
+        search_for_movie: true,
-      Ok(response) => match method {
-        RequestMethod::GET => match utils::parse_response::<T>(response).await {
-          Ok(value) => {
-            let app = self.app.lock().await;
-            app_update_fn(value, app);
-          }
-          Err(e) => {
-            error!("Failed to parse response! {:?}", e);
-            self.app.lock().await.handle_error(anyhow!(e));
-          }
       },
-        RequestMethod::DELETE => {
+    };
-          if response.status() != StatusCode::OK {
+
-            error!(
+    debug!("Add movie body: {:?}", body);
-              "Received the following code for delete operation: {:?}",
+
-              response.status()
+    let request_props = self
-            );
+      .radarr_request_props_from(
-            self.app.lock().await.handle_error(anyhow!(
+        RadarrEvent::AddMovie.resource(),
-              "Received a non 200 OK response for delete operation"
+        RequestMethod::Post,
-            ));
+        Some(body),
-          }
+      )
-        }
+      .await;
-      },
+
-      Err(e) => {
+    self
-        error!("Failed to send request. {:?}", e);
+      .handle_request::<AddMovieBody, ()>(request_props, |_, _| ())
-        self.app.lock().await.handle_error(anyhow!(e));
+      .await;
-      }
-    }
   }
 
   async fn extract_movie_id(&self) -> u64 {
@@ -594,6 +596,33 @@ impl<'a> Network<'a> {
 
   async fn append_movie_id_param(&self, resource: &str) -> String {
     let movie_id = self.extract_movie_id().await;
-    format!("{}?movieId={}", resource.to_owned(), movie_id.to_owned())
+    format!("{}?movieId={}", resource, movie_id)
+  }
+
+  async fn radarr_request_props_from<T: Serialize + Debug>(
+    &self,
+    resource: &str,
+    method: RequestMethod,
+    body: Option<T>,
+  ) -> RequestProps<T> {
+    let app = self.app.lock().await;
+    let RadarrConfig {
+      host,
+      port,
+      api_token,
+    } = &app.config.radarr;
+    let uri = format!(
+      "http://{}:{}/api/v3{}",
+      host,
+      port.unwrap_or(7878),
+      resource
+    );
+
+    RequestProps {
+      uri,
+      method,
+      body,
+      api_token: api_token.to_owned(),
+    }
   }
 }

src/ui/mod.rs

@@ -54,9 +54,8 @@ pub fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {
 
   draw_header_row(f, app, main_chunks[0]);
   draw_context_row(f, app, main_chunks[1]);
-  match app.get_current_route() {
+  if let Route::Radarr(_) = app.get_current_route() {
-    Route::Radarr(_) => radarr_ui::draw_radarr_ui(f, app, main_chunks[2]),
+    radarr_ui::draw_radarr_ui(f, app, main_chunks[2])
-    _ => (),
   }
 }
 
@@ -152,9 +151,8 @@ pub fn draw_large_popup_over<B: Backend>(
 }
 
 fn draw_context_row<B: Backend>(f: &mut Frame<'_, B>, app: &App, area: Rect) {
-  match app.get_current_route() {
+  if let Route::Radarr(_) = app.get_current_route() {
-    Route::Radarr(_) => radarr_ui::draw_radarr_context_row(f, app, area),
+    radarr_ui::draw_radarr_context_row(f, app, area)
-    _ => (),
   }
 }
 

src/ui/radarr_ui/mod.rs

@@ -6,14 +6,14 @@ use tui::backend::Backend;
 use tui::layout::{Alignment, Constraint, Rect};
 use tui::style::{Color, Style};
 use tui::text::Text;
-use tui::widgets::{Cell, Paragraph, Row};
+use tui::widgets::{Block, Cell, Paragraph, Row};
 use tui::Frame;
 
 use crate::app::radarr::{ActiveRadarrBlock, RadarrData};
 use crate::app::App;
 use crate::logos::RADARR_LOGO;
-use crate::models::radarr_models::{DiskSpace, DownloadRecord, Movie};
+use crate::models::radarr_models::{AddMovieSearchResult, DiskSpace, DownloadRecord, Movie};
-use crate::models::Route;
+use crate::models::{Route, StatefulTable};
 use crate::ui::radarr_ui::add_movie_ui::draw_add_movie_search_popup;
 use crate::ui::radarr_ui::collection_details_ui::draw_collection_details_popup;
 use crate::ui::radarr_ui::movie_details_ui::draw_movie_info;

src/ui/utils.rs

@@ -6,10 +6,7 @@ use tui::widgets::{Block, Borders, LineGauge};
 use tui::{symbols, Frame};
 
 pub fn horizontal_chunks(constraints: Vec<Constraint>, size: Rect) -> Vec<Rect> {
-  Layout::default()
+  layout_with_constraints(constraints)
-    .constraints(<Vec<Constraint> as AsRef<[Constraint]>>::as_ref(
-      &constraints,
-    ))
     .direction(Direction::Horizontal)
     .split(size)
 }
@@ -19,20 +16,14 @@ pub fn horizontal_chunks_with_margin(
   size: Rect,
   margin: u16,
 ) -> Vec<Rect> {
-  Layout::default()
+  layout_with_constraints(constraints)
-    .constraints(<Vec<Constraint> as AsRef<[Constraint]>>::as_ref(
-      &constraints,
-    ))
     .direction(Direction::Horizontal)
     .margin(margin)
     .split(size)
 }
 
 pub fn vertical_chunks(constraints: Vec<Constraint>, size: Rect) -> Vec<Rect> {
-  Layout::default()
+  layout_with_constraints(constraints)
-    .constraints(<Vec<Constraint> as AsRef<[Constraint]>>::as_ref(
-      &constraints,
-    ))
     .direction(Direction::Vertical)
     .split(size)
 }
@@ -42,15 +33,18 @@ pub fn vertical_chunks_with_margin(
   size: Rect,
   margin: u16,
 ) -> Vec<Rect> {
-  Layout::default()
+  layout_with_constraints(constraints)
-    .constraints(<Vec<Constraint> as AsRef<[Constraint]>>::as_ref(
-      &constraints,
-    ))
     .direction(Direction::Vertical)
     .margin(margin)
     .split(size)
 }
 
+fn layout_with_constraints(constraints: Vec<Constraint>) -> Layout {
+  Layout::default().constraints(<Vec<Constraint> as AsRef<[Constraint]>>::as_ref(
+    &constraints,
+  ))
+}
+
 pub fn layout_block<'a>() -> Block<'a> {
   Block::default().borders(Borders::ALL)
 }
@@ -167,17 +161,14 @@ pub fn logo_block<'a>() -> Block<'a> {
 }
 
 pub fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
-  let popup_layout = Layout::default()
+  let popup_layout = vertical_chunks(
-    .direction(Direction::Vertical)
+    vec![
-    .constraints(
-      [
       Constraint::Percentage((100 - percent_y) / 2),
       Constraint::Percentage(percent_y),
       Constraint::Percentage((100 - percent_y) / 2),
-      ]
+    ],
-      .as_ref(),
+    r,
-    )
+  );
-    .split(r);
 
   Layout::default()
     .direction(Direction::Horizontal)