feat: Full support for adding a root folder in Lidarr from both the CLI and TUI

src/handlers/lidarr_handlers/root_folders/add_root_folder_handler.rs

@@ -0,0 +1,533 @@
+use crate::app::App;
+use crate::event::Key;
+use crate::handlers::{KeyEventHandler, handle_prompt_toggle};
+use crate::models::lidarr_models::AddLidarrRootFolderBody;
+use crate::models::servarr_data::lidarr::lidarr_data::{ADD_ROOT_FOLDER_BLOCKS, ActiveLidarrBlock};
+use crate::models::servarr_data::lidarr::modals::AddRootFolderModal;
+use crate::models::{Route, Scrollable};
+use crate::network::lidarr_network::LidarrEvent;
+use crate::{handle_text_box_keys, handle_text_box_left_right_keys, matches_key};
+
+#[cfg(test)]
+#[path = "add_root_folder_handler_tests.rs"]
+mod add_root_folder_handler_tests;
+
+pub(super) struct AddRootFolderHandler<'a, 'b> {
+  key: Key,
+  app: &'a mut App<'b>,
+  active_lidarr_block: ActiveLidarrBlock,
+  context: Option<ActiveLidarrBlock>,
+}
+
+impl AddRootFolderHandler<'_, '_> {
+  fn build_add_root_folder_body(&mut self) -> AddLidarrRootFolderBody {
+    let add_root_folder_modal = self
+      .app
+      .data
+      .lidarr_data
+      .add_root_folder_modal
+      .take()
+      .expect("AddRootFolderModal is None");
+
+    let tags = add_root_folder_modal.tags.text.clone();
+
+    let AddRootFolderModal {
+      name,
+      path,
+      monitor_list,
+      monitor_new_items_list,
+      quality_profile_list,
+      metadata_profile_list,
+      ..
+    } = add_root_folder_modal;
+
+    let quality_profile = quality_profile_list.current_selection();
+    let quality_profile_id = *self
+      .app
+      .data
+      .lidarr_data
+      .quality_profile_map
+      .iter()
+      .filter(|(_, value)| *value == quality_profile)
+      .map(|(key, _)| key)
+      .next()
+      .unwrap();
+
+    let metadata_profile = metadata_profile_list.current_selection();
+    let metadata_profile_id = *self
+      .app
+      .data
+      .lidarr_data
+      .metadata_profile_map
+      .iter()
+      .filter(|(_, value)| *value == metadata_profile)
+      .map(|(key, _)| key)
+      .next()
+      .unwrap();
+
+    AddLidarrRootFolderBody {
+      name: name.text,
+      path: path.text,
+      default_quality_profile_id: quality_profile_id,
+      default_metadata_profile_id: metadata_profile_id,
+      default_monitor_option: *monitor_list.current_selection(),
+      default_new_item_monitor_option: *monitor_new_items_list.current_selection(),
+      default_tags: Vec::new(),
+      tag_input_string: Some(tags),
+    }
+  }
+}
+
+impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveLidarrBlock> for AddRootFolderHandler<'a, 'b> {
+  fn accepts(active_block: ActiveLidarrBlock) -> bool {
+    ADD_ROOT_FOLDER_BLOCKS.contains(&active_block)
+  }
+
+  fn ignore_special_keys(&self) -> bool {
+    self.app.ignore_special_keys_for_textbox_input
+  }
+
+  fn new(
+    key: Key,
+    app: &'a mut App<'b>,
+    active_block: ActiveLidarrBlock,
+    context: Option<ActiveLidarrBlock>,
+  ) -> AddRootFolderHandler<'a, 'b> {
+    AddRootFolderHandler {
+      key,
+      app,
+      active_lidarr_block: active_block,
+      context,
+    }
+  }
+
+  fn get_key(&self) -> Key {
+    self.key
+  }
+
+  fn is_ready(&self) -> bool {
+    !self.app.is_loading && self.app.data.lidarr_data.add_root_folder_modal.is_some()
+  }
+
+  fn handle_scroll_up(&mut self) {
+    match self.active_lidarr_block {
+      ActiveLidarrBlock::AddRootFolderSelectMonitor => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .monitor_list
+        .scroll_up(),
+      ActiveLidarrBlock::AddRootFolderSelectMonitorNewItems => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .monitor_new_items_list
+        .scroll_up(),
+      ActiveLidarrBlock::AddRootFolderSelectQualityProfile => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .quality_profile_list
+        .scroll_up(),
+      ActiveLidarrBlock::AddRootFolderSelectMetadataProfile => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .metadata_profile_list
+        .scroll_up(),
+      ActiveLidarrBlock::AddRootFolderPrompt => self.app.data.lidarr_data.selected_block.up(),
+      _ => (),
+    }
+  }
+
+  fn handle_scroll_down(&mut self) {
+    match self.active_lidarr_block {
+      ActiveLidarrBlock::AddRootFolderSelectMonitor => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .monitor_list
+        .scroll_down(),
+      ActiveLidarrBlock::AddRootFolderSelectMonitorNewItems => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .monitor_new_items_list
+        .scroll_down(),
+      ActiveLidarrBlock::AddRootFolderSelectQualityProfile => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .quality_profile_list
+        .scroll_down(),
+      ActiveLidarrBlock::AddRootFolderSelectMetadataProfile => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .metadata_profile_list
+        .scroll_down(),
+      ActiveLidarrBlock::AddRootFolderPrompt => self.app.data.lidarr_data.selected_block.down(),
+      _ => (),
+    }
+  }
+
+  fn handle_home(&mut self) {
+    match self.active_lidarr_block {
+      ActiveLidarrBlock::AddRootFolderSelectMonitor => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .monitor_list
+        .scroll_to_top(),
+      ActiveLidarrBlock::AddRootFolderSelectMonitorNewItems => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .monitor_new_items_list
+        .scroll_to_top(),
+      ActiveLidarrBlock::AddRootFolderSelectQualityProfile => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .quality_profile_list
+        .scroll_to_top(),
+      ActiveLidarrBlock::AddRootFolderSelectMetadataProfile => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .metadata_profile_list
+        .scroll_to_top(),
+      ActiveLidarrBlock::AddRootFolderNameInput => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .name
+        .scroll_home(),
+      ActiveLidarrBlock::AddRootFolderPathInput => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .path
+        .scroll_home(),
+      ActiveLidarrBlock::AddRootFolderTagsInput => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .tags
+        .scroll_home(),
+      _ => (),
+    }
+  }
+
+  fn handle_end(&mut self) {
+    match self.active_lidarr_block {
+      ActiveLidarrBlock::AddRootFolderSelectMonitor => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .monitor_list
+        .scroll_to_bottom(),
+      ActiveLidarrBlock::AddRootFolderSelectMonitorNewItems => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .monitor_new_items_list
+        .scroll_to_bottom(),
+      ActiveLidarrBlock::AddRootFolderSelectQualityProfile => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .quality_profile_list
+        .scroll_to_bottom(),
+      ActiveLidarrBlock::AddRootFolderSelectMetadataProfile => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .metadata_profile_list
+        .scroll_to_bottom(),
+      ActiveLidarrBlock::AddRootFolderNameInput => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .name
+        .reset_offset(),
+      ActiveLidarrBlock::AddRootFolderPathInput => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .path
+        .reset_offset(),
+      ActiveLidarrBlock::AddRootFolderTagsInput => self
+        .app
+        .data
+        .lidarr_data
+        .add_root_folder_modal
+        .as_mut()
+        .unwrap()
+        .tags
+        .reset_offset(),
+      _ => (),
+    }
+  }
+
+  fn handle_delete(&mut self) {}
+
+  fn handle_left_right_action(&mut self) {
+    match self.active_lidarr_block {
+      ActiveLidarrBlock::AddRootFolderPrompt => handle_prompt_toggle(self.app, self.key),
+      ActiveLidarrBlock::AddRootFolderNameInput => {
+        handle_text_box_left_right_keys!(
+          self,
+          self.key,
+          self
+            .app
+            .data
+            .lidarr_data
+            .add_root_folder_modal
+            .as_mut()
+            .unwrap()
+            .name
+        )
+      }
+      ActiveLidarrBlock::AddRootFolderPathInput => {
+        handle_text_box_left_right_keys!(
+          self,
+          self.key,
+          self
+            .app
+            .data
+            .lidarr_data
+            .add_root_folder_modal
+            .as_mut()
+            .unwrap()
+            .path
+        )
+      }
+      ActiveLidarrBlock::AddRootFolderTagsInput => {
+        handle_text_box_left_right_keys!(
+          self,
+          self.key,
+          self
+            .app
+            .data
+            .lidarr_data
+            .add_root_folder_modal
+            .as_mut()
+            .unwrap()
+            .tags
+        )
+      }
+      _ => (),
+    }
+  }
+
+  fn handle_submit(&mut self) {
+    match self.active_lidarr_block {
+      ActiveLidarrBlock::AddRootFolderPrompt => {
+        match self.app.data.lidarr_data.selected_block.get_active_block() {
+          ActiveLidarrBlock::AddRootFolderConfirmPrompt => {
+            if self.app.data.lidarr_data.prompt_confirm {
+              self.app.data.lidarr_data.prompt_confirm_action = Some(LidarrEvent::AddRootFolder(
+                self.build_add_root_folder_body(),
+              ));
+              self.app.should_refresh = true;
+            }
+
+            self.app.pop_navigation_stack();
+          }
+          ActiveLidarrBlock::AddRootFolderSelectMonitor
+          | ActiveLidarrBlock::AddRootFolderSelectMonitorNewItems
+          | ActiveLidarrBlock::AddRootFolderSelectQualityProfile
+          | ActiveLidarrBlock::AddRootFolderSelectMetadataProfile => {
+            self.app.push_navigation_stack(
+              (
+                self.app.data.lidarr_data.selected_block.get_active_block(),
+                self.context,
+              )
+                .into(),
+            )
+          }
+          ActiveLidarrBlock::AddRootFolderNameInput
+          | ActiveLidarrBlock::AddRootFolderPathInput
+          | ActiveLidarrBlock::AddRootFolderTagsInput => {
+            self.app.push_navigation_stack(
+              (
+                self.app.data.lidarr_data.selected_block.get_active_block(),
+                self.context,
+              )
+                .into(),
+            );
+            self.app.ignore_special_keys_for_textbox_input = true;
+          }
+          _ => (),
+        }
+      }
+      ActiveLidarrBlock::AddRootFolderSelectMonitor
+      | ActiveLidarrBlock::AddRootFolderSelectMonitorNewItems
+      | ActiveLidarrBlock::AddRootFolderSelectQualityProfile
+      | ActiveLidarrBlock::AddRootFolderSelectMetadataProfile => self.app.pop_navigation_stack(),
+      ActiveLidarrBlock::AddRootFolderNameInput
+      | ActiveLidarrBlock::AddRootFolderPathInput
+      | ActiveLidarrBlock::AddRootFolderTagsInput => {
+        self.app.pop_navigation_stack();
+        self.app.ignore_special_keys_for_textbox_input = false;
+      }
+      _ => (),
+    }
+  }
+
+  fn handle_esc(&mut self) {
+    match self.active_lidarr_block {
+      ActiveLidarrBlock::AddRootFolderNameInput
+      | ActiveLidarrBlock::AddRootFolderPathInput
+      | ActiveLidarrBlock::AddRootFolderTagsInput => {
+        self.app.pop_navigation_stack();
+        self.app.ignore_special_keys_for_textbox_input = false;
+      }
+      ActiveLidarrBlock::AddRootFolderPrompt => {
+        self.app.pop_navigation_stack();
+        self.app.data.lidarr_data.add_root_folder_modal = None;
+        self.app.data.lidarr_data.prompt_confirm = false;
+      }
+      ActiveLidarrBlock::AddRootFolderSelectMonitor
+      | ActiveLidarrBlock::AddRootFolderSelectMonitorNewItems
+      | ActiveLidarrBlock::AddRootFolderSelectQualityProfile
+      | ActiveLidarrBlock::AddRootFolderSelectMetadataProfile => self.app.pop_navigation_stack(),
+      _ => (),
+    }
+  }
+
+  fn handle_char_key_event(&mut self) {
+    let key = self.key;
+    match self.active_lidarr_block {
+      ActiveLidarrBlock::AddRootFolderNameInput => {
+        handle_text_box_keys!(
+          self,
+          key,
+          self
+            .app
+            .data
+            .lidarr_data
+            .add_root_folder_modal
+            .as_mut()
+            .unwrap()
+            .name
+        )
+      }
+      ActiveLidarrBlock::AddRootFolderPathInput => {
+        handle_text_box_keys!(
+          self,
+          key,
+          self
+            .app
+            .data
+            .lidarr_data
+            .add_root_folder_modal
+            .as_mut()
+            .unwrap()
+            .path
+        )
+      }
+      ActiveLidarrBlock::AddRootFolderTagsInput => {
+        handle_text_box_keys!(
+          self,
+          key,
+          self
+            .app
+            .data
+            .lidarr_data
+            .add_root_folder_modal
+            .as_mut()
+            .unwrap()
+            .tags
+        )
+      }
+      ActiveLidarrBlock::AddRootFolderPrompt => {
+        if self.app.data.lidarr_data.selected_block.get_active_block()
+          == ActiveLidarrBlock::AddRootFolderConfirmPrompt
+          && matches_key!(confirm, key)
+        {
+          self.app.data.lidarr_data.prompt_confirm = true;
+          self.app.data.lidarr_data.prompt_confirm_action = Some(LidarrEvent::AddRootFolder(
+            self.build_add_root_folder_body(),
+          ));
+          self.app.should_refresh = true;
+
+          self.app.pop_navigation_stack();
+        }
+      }
+      _ => (),
+    }
+  }
+
+  fn app_mut(&mut self) -> &mut App<'b> {
+    self.app
+  }
+
+  fn current_route(&self) -> Route {
+    self.app.get_current_route()
+  }
+}

src/handlers/lidarr_handlers/root_folders/mod.rs

@@ -1,13 +1,19 @@
+use add_root_folder_handler::AddRootFolderHandler;
+
 use crate::app::App;
 use crate::event::Key;
 use crate::handlers::lidarr_handlers::handle_change_tab_left_right_keys;
 use crate::handlers::table_handler::{TableHandlingConfig, handle_table};
 use crate::handlers::{KeyEventHandler, handle_clear_errors, handle_prompt_toggle};
-use crate::models::servarr_data::lidarr::lidarr_data::{ActiveLidarrBlock, ROOT_FOLDERS_BLOCKS};
-use crate::models::servarr_models::AddRootFolderBody;
-use crate::models::{HorizontallyScrollableText, Route};
+use crate::matches_key;
+use crate::models::servarr_data::lidarr::lidarr_data::{
+  ADD_ROOT_FOLDER_BLOCKS, ADD_ROOT_FOLDER_SELECTION_BLOCKS, ActiveLidarrBlock, ROOT_FOLDERS_BLOCKS,
+};
+use crate::models::servarr_data::lidarr::modals::AddRootFolderModal;
+use crate::models::{BlockSelectionState, Route};
 use crate::network::lidarr_network::LidarrEvent;
-use crate::{handle_text_box_keys, handle_text_box_left_right_keys, matches_key};
+
+mod add_root_folder_handler;
 
 #[cfg(test)]
 #[path = "root_folders_handler_tests.rs"]
@@ -17,22 +23,10 @@ pub(super) struct RootFoldersHandler<'a, 'b> {
   key: Key,
   app: &'a mut App<'b>,
   active_lidarr_block: ActiveLidarrBlock,
-  _context: Option<ActiveLidarrBlock>,
+  context: Option<ActiveLidarrBlock>,
 }
 
 impl RootFoldersHandler<'_, '_> {
-  fn build_add_root_folder_body(&mut self) -> AddRootFolderBody {
-    let root_folder = self
-      .app
-      .data
-      .lidarr_data
-      .edit_root_folder
-      .take()
-      .expect("EditRootFolder is None")
-      .text;
-    AddRootFolderBody { path: root_folder }
-  }
-
   fn extract_root_folder_id(&self) -> i64 {
     self
       .app
@@ -49,6 +43,11 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveLidarrBlock> for RootFoldersHandler<'
     let root_folders_table_handling_config =
       TableHandlingConfig::new(ActiveLidarrBlock::RootFolders.into());
 
+    if AddRootFolderHandler::accepts(self.active_lidarr_block) {
+      return AddRootFolderHandler::new(self.key, self.app, self.active_lidarr_block, self.context)
+        .handle();
+    }
+
     if !handle_table(
       self,
       |app| &mut app.data.lidarr_data.root_folders,
@@ -59,20 +58,20 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveLidarrBlock> for RootFoldersHandler<'
   }
 
   fn accepts(active_block: ActiveLidarrBlock) -> bool {
-    ROOT_FOLDERS_BLOCKS.contains(&active_block)
+    ROOT_FOLDERS_BLOCKS.contains(&active_block) || ADD_ROOT_FOLDER_BLOCKS.contains(&active_block)
   }
 
   fn new(
     key: Key,
     app: &'a mut App<'b>,
     active_block: ActiveLidarrBlock,
-    _context: Option<ActiveLidarrBlock>,
+    context: Option<ActiveLidarrBlock>,
   ) -> RootFoldersHandler<'a, 'b> {
     RootFoldersHandler {
       key,
       app,
       active_lidarr_block: active_block,
-      _context,
+      context,
     }
   }
 
@@ -92,31 +91,9 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveLidarrBlock> for RootFoldersHandler<'
 
   fn handle_scroll_down(&mut self) {}
 
-  fn handle_home(&mut self) {
-    if self.active_lidarr_block == ActiveLidarrBlock::AddRootFolderPrompt {
-      self
-        .app
-        .data
-        .lidarr_data
-        .edit_root_folder
-        .as_mut()
-        .unwrap()
-        .scroll_home()
-    }
-  }
+  fn handle_home(&mut self) {}
 
-  fn handle_end(&mut self) {
-    if self.active_lidarr_block == ActiveLidarrBlock::AddRootFolderPrompt {
-      self
-        .app
-        .data
-        .lidarr_data
-        .edit_root_folder
-        .as_mut()
-        .unwrap()
-        .reset_offset()
-    }
-  }
+  fn handle_end(&mut self) {}
 
   fn handle_delete(&mut self) {
     if self.active_lidarr_block == ActiveLidarrBlock::RootFolders {
@@ -130,57 +107,23 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveLidarrBlock> for RootFoldersHandler<'
     match self.active_lidarr_block {
       ActiveLidarrBlock::RootFolders => handle_change_tab_left_right_keys(self.app, self.key),
       ActiveLidarrBlock::DeleteRootFolderPrompt => handle_prompt_toggle(self.app, self.key),
-      ActiveLidarrBlock::AddRootFolderPrompt => {
-        handle_text_box_left_right_keys!(
-          self,
-          self.key,
-          self.app.data.lidarr_data.edit_root_folder.as_mut().unwrap()
-        )
-      }
       _ => (),
     }
   }
 
   fn handle_submit(&mut self) {
-    match self.active_lidarr_block {
-      ActiveLidarrBlock::DeleteRootFolderPrompt => {
-        if self.app.data.lidarr_data.prompt_confirm {
-          self.app.data.lidarr_data.prompt_confirm_action =
-            Some(LidarrEvent::DeleteRootFolder(self.extract_root_folder_id()));
-        }
+    if self.active_lidarr_block == ActiveLidarrBlock::DeleteRootFolderPrompt {
+      if self.app.data.lidarr_data.prompt_confirm {
+        self.app.data.lidarr_data.prompt_confirm_action =
+          Some(LidarrEvent::DeleteRootFolder(self.extract_root_folder_id()));
+      }
 
-        self.app.pop_navigation_stack();
-      }
-      _ if self.active_lidarr_block == ActiveLidarrBlock::AddRootFolderPrompt
-        && !self
-          .app
-          .data
-          .lidarr_data
-          .edit_root_folder
-          .as_ref()
-          .unwrap()
-          .text
-          .is_empty() =>
-      {
-        self.app.data.lidarr_data.prompt_confirm_action = Some(LidarrEvent::AddRootFolder(
-          self.build_add_root_folder_body(),
-        ));
-        self.app.data.lidarr_data.prompt_confirm = true;
-        self.app.ignore_special_keys_for_textbox_input = false;
-        self.app.pop_navigation_stack();
-      }
-      _ => (),
+      self.app.pop_navigation_stack();
     }
   }
 
   fn handle_esc(&mut self) {
     match self.active_lidarr_block {
-      ActiveLidarrBlock::AddRootFolderPrompt => {
-        self.app.pop_navigation_stack();
-        self.app.data.lidarr_data.edit_root_folder = None;
-        self.app.data.lidarr_data.prompt_confirm = false;
-        self.app.ignore_special_keys_for_textbox_input = false;
-      }
       ActiveLidarrBlock::DeleteRootFolderPrompt => {
         self.app.pop_navigation_stack();
         self.app.data.lidarr_data.prompt_confirm = false;
@@ -197,21 +140,16 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveLidarrBlock> for RootFoldersHandler<'
           self.app.should_refresh = true;
         }
         _ if matches_key!(add, key) => {
+          self.app.data.lidarr_data.add_root_folder_modal =
+            Some(AddRootFolderModal::from(&self.app.data.lidarr_data));
+          self.app.data.lidarr_data.selected_block =
+            BlockSelectionState::new(ADD_ROOT_FOLDER_SELECTION_BLOCKS);
           self
             .app
             .push_navigation_stack(ActiveLidarrBlock::AddRootFolderPrompt.into());
-          self.app.data.lidarr_data.edit_root_folder = Some(HorizontallyScrollableText::default());
-          self.app.ignore_special_keys_for_textbox_input = true;
         }
         _ => (),
       },
-      ActiveLidarrBlock::AddRootFolderPrompt => {
-        handle_text_box_keys!(
-          self,
-          key,
-          self.app.data.lidarr_data.edit_root_folder.as_mut().unwrap()
-        )
-      }
       ActiveLidarrBlock::DeleteRootFolderPrompt => {
         if matches_key!(confirm, key) {
           self.app.data.lidarr_data.prompt_confirm = true;

src/handlers/lidarr_handlers/root_folders/root_folders_handler_tests.rs

@@ -6,78 +6,17 @@ mod tests {
 
   use crate::app::App;
   use crate::app::key_binding::DEFAULT_KEYBINDINGS;
-  use crate::assert_modal_absent;
   use crate::assert_modal_present;
   use crate::assert_navigation_pushed;
   use crate::event::Key;
   use crate::handlers::KeyEventHandler;
   use crate::handlers::lidarr_handlers::root_folders::RootFoldersHandler;
-  use crate::models::HorizontallyScrollableText;
-  use crate::models::servarr_data::lidarr::lidarr_data::{ActiveLidarrBlock, ROOT_FOLDERS_BLOCKS};
-  use crate::models::servarr_models::{AddRootFolderBody, RootFolder};
+  use crate::models::servarr_data::lidarr::lidarr_data::{
+    ADD_ROOT_FOLDER_BLOCKS, ActiveLidarrBlock, ROOT_FOLDERS_BLOCKS,
+  };
+  use crate::models::servarr_models::RootFolder;
   use crate::network::lidarr_network::lidarr_network_test_utils::test_utils::root_folder;
 
-  mod test_handle_home_end {
-    use crate::models::servarr_models::RootFolder;
-    use pretty_assertions::assert_eq;
-    use std::sync::atomic::Ordering;
-
-    use super::*;
-
-    #[test]
-    fn test_add_root_folder_prompt_home_end_keys() {
-      let mut app = App::test_default();
-      app.push_navigation_stack(ActiveLidarrBlock::RootFolders.into());
-      app.push_navigation_stack(ActiveLidarrBlock::AddRootFolderPrompt.into());
-      app
-        .data
-        .lidarr_data
-        .root_folders
-        .set_items(vec![RootFolder::default()]);
-      app.data.lidarr_data.edit_root_folder = Some("Test".into());
-
-      RootFoldersHandler::new(
-        DEFAULT_KEYBINDINGS.home.key,
-        &mut app,
-        ActiveLidarrBlock::AddRootFolderPrompt,
-        None,
-      )
-      .handle();
-
-      assert_eq!(
-        app
-          .data
-          .lidarr_data
-          .edit_root_folder
-          .as_ref()
-          .unwrap()
-          .offset
-          .load(Ordering::SeqCst),
-        4
-      );
-
-      RootFoldersHandler::new(
-        DEFAULT_KEYBINDINGS.end.key,
-        &mut app,
-        ActiveLidarrBlock::AddRootFolderPrompt,
-        None,
-      )
-      .handle();
-
-      assert_eq!(
-        app
-          .data
-          .lidarr_data
-          .edit_root_folder
-          .as_ref()
-          .unwrap()
-          .offset
-          .load(Ordering::SeqCst),
-        0
-      );
-    }
-  }
-
   mod test_handle_delete {
     use pretty_assertions::assert_eq;
 
@@ -121,8 +60,6 @@ mod tests {
   }
 
   mod test_handle_left_right_action {
-    use std::sync::atomic::Ordering;
-
     use pretty_assertions::assert_eq;
     use rstest::rstest;
 
@@ -200,127 +137,17 @@ mod tests {
 
       assert!(!app.data.lidarr_data.prompt_confirm);
     }
-
-    #[test]
-    fn test_add_root_folder_prompt_left_right_keys() {
-      let mut app = App::test_default();
-      app.push_navigation_stack(ActiveLidarrBlock::RootFolders.into());
-      app.data.lidarr_data.edit_root_folder = Some("Test".into());
-
-      RootFoldersHandler::new(
-        DEFAULT_KEYBINDINGS.left.key,
-        &mut app,
-        ActiveLidarrBlock::AddRootFolderPrompt,
-        None,
-      )
-      .handle();
-
-      assert_eq!(
-        app
-          .data
-          .lidarr_data
-          .edit_root_folder
-          .as_ref()
-          .unwrap()
-          .offset
-          .load(Ordering::SeqCst),
-        1
-      );
-
-      RootFoldersHandler::new(
-        DEFAULT_KEYBINDINGS.right.key,
-        &mut app,
-        ActiveLidarrBlock::AddRootFolderPrompt,
-        None,
-      )
-      .handle();
-
-      assert_eq!(
-        app
-          .data
-          .lidarr_data
-          .edit_root_folder
-          .as_ref()
-          .unwrap()
-          .offset
-          .load(Ordering::SeqCst),
-        0
-      );
-    }
   }
 
   mod test_handle_submit {
-    use pretty_assertions::assert_eq;
-
     use crate::network::lidarr_network::LidarrEvent;
 
     use super::*;
+    use crate::assert_navigation_popped;
     use crate::network::lidarr_network::lidarr_network_test_utils::test_utils::root_folder;
-    use crate::{assert_modal_absent, assert_navigation_popped};
 
     const SUBMIT_KEY: Key = DEFAULT_KEYBINDINGS.submit.key;
 
-    #[test]
-    fn test_add_root_folder_prompt_confirm_submit() {
-      let mut app = App::test_default();
-      let expected_add_root_folder_body = AddRootFolderBody {
-        path: "Test".to_owned(),
-      };
-      app
-        .data
-        .lidarr_data
-        .root_folders
-        .set_items(vec![RootFolder::default()]);
-      app.data.lidarr_data.edit_root_folder = Some("Test".into());
-      app.data.lidarr_data.prompt_confirm = true;
-      app.ignore_special_keys_for_textbox_input = true;
-      app.push_navigation_stack(ActiveLidarrBlock::RootFolders.into());
-      app.push_navigation_stack(ActiveLidarrBlock::AddRootFolderPrompt.into());
-
-      RootFoldersHandler::new(
-        SUBMIT_KEY,
-        &mut app,
-        ActiveLidarrBlock::AddRootFolderPrompt,
-        None,
-      )
-      .handle();
-
-      assert!(app.data.lidarr_data.prompt_confirm);
-      assert!(!app.ignore_special_keys_for_textbox_input);
-      assert_eq!(
-        app.data.lidarr_data.prompt_confirm_action,
-        Some(LidarrEvent::AddRootFolder(expected_add_root_folder_body))
-      );
-      assert_navigation_popped!(app, ActiveLidarrBlock::RootFolders.into());
-      assert_modal_absent!(app.data.lidarr_data.edit_root_folder);
-    }
-
-    #[test]
-    fn test_add_root_folder_prompt_confirm_submit_noop_on_empty_folder() {
-      let mut app = App::test_default();
-      app.data.lidarr_data.edit_root_folder = Some(HorizontallyScrollableText::default());
-      app.data.lidarr_data.prompt_confirm = false;
-      app.ignore_special_keys_for_textbox_input = true;
-      app.push_navigation_stack(ActiveLidarrBlock::RootFolders.into());
-      app.push_navigation_stack(ActiveLidarrBlock::AddRootFolderPrompt.into());
-
-      RootFoldersHandler::new(
-        SUBMIT_KEY,
-        &mut app,
-        ActiveLidarrBlock::AddRootFolderPrompt,
-        None,
-      )
-      .handle();
-
-      assert!(!app.data.lidarr_data.prompt_confirm);
-      assert!(app.ignore_special_keys_for_textbox_input);
-      assert_modal_absent!(app.data.lidarr_data.prompt_confirm_action);
-      assert_eq!(
-        app.get_current_route(),
-        ActiveLidarrBlock::AddRootFolderPrompt.into()
-      );
-    }
-
     #[test]
     fn test_delete_root_folder_prompt_confirm_submit() {
       let mut app = App::test_default();
@@ -400,29 +227,6 @@ mod tests {
       assert!(!app.data.lidarr_data.prompt_confirm);
     }
 
-    #[test]
-    fn test_add_root_folder_prompt_esc() {
-      let mut app = App::test_default();
-      app.push_navigation_stack(ActiveLidarrBlock::RootFolders.into());
-      app.push_navigation_stack(ActiveLidarrBlock::AddRootFolderPrompt.into());
-      app.data.lidarr_data.edit_root_folder = Some("/nfs/test".into());
-      app.ignore_special_keys_for_textbox_input = true;
-
-      RootFoldersHandler::new(
-        ESC_KEY,
-        &mut app,
-        ActiveLidarrBlock::AddRootFolderPrompt,
-        None,
-      )
-      .handle();
-
-      assert_navigation_popped!(app, ActiveLidarrBlock::RootFolders.into());
-
-      assert_modal_absent!(app.data.lidarr_data.edit_root_folder);
-      assert!(!app.data.lidarr_data.prompt_confirm);
-      assert!(!app.ignore_special_keys_for_textbox_input);
-    }
-
     #[rstest]
     fn test_default_esc(#[values(true, false)] is_ready: bool) {
       let mut app = App::test_default();
@@ -443,7 +247,7 @@ mod tests {
     use crate::assert_navigation_popped;
     use crate::network::lidarr_network::LidarrEvent;
     use crate::network::lidarr_network::lidarr_network_test_utils::test_utils::root_folder;
-    use pretty_assertions::{assert_eq, assert_str_eq};
+    use pretty_assertions::assert_eq;
 
     #[test]
     fn test_root_folder_add() {
@@ -464,8 +268,7 @@ mod tests {
       .handle();
 
       assert_navigation_pushed!(app, ActiveLidarrBlock::AddRootFolderPrompt.into());
-      assert!(app.ignore_special_keys_for_textbox_input);
-      assert_modal_present!(app.data.lidarr_data.edit_root_folder);
+      assert_modal_present!(app.data.lidarr_data.add_root_folder_modal);
     }
 
     #[test]
@@ -491,8 +294,7 @@ mod tests {
         app.get_current_route(),
         ActiveLidarrBlock::RootFolders.into()
       );
-      assert!(!app.ignore_special_keys_for_textbox_input);
-      assert_modal_absent!(app.data.lidarr_data.edit_root_folder);
+      assert_none!(app.data.lidarr_data.add_root_folder_modal);
     }
 
     #[test]
@@ -543,56 +345,6 @@ mod tests {
       assert!(!app.should_refresh);
     }
 
-    #[test]
-    fn test_add_root_folder_prompt_backspace_key() {
-      let mut app = App::test_default();
-      app.push_navigation_stack(ActiveLidarrBlock::RootFolders.into());
-      app
-        .data
-        .lidarr_data
-        .root_folders
-        .set_items(vec![RootFolder::default()]);
-      app.data.lidarr_data.edit_root_folder = Some("/nfs/test".into());
-
-      RootFoldersHandler::new(
-        DEFAULT_KEYBINDINGS.backspace.key,
-        &mut app,
-        ActiveLidarrBlock::AddRootFolderPrompt,
-        None,
-      )
-      .handle();
-
-      assert_str_eq!(
-        app.data.lidarr_data.edit_root_folder.as_ref().unwrap().text,
-        "/nfs/tes"
-      );
-    }
-
-    #[test]
-    fn test_add_root_folder_prompt_char_key() {
-      let mut app = App::test_default();
-      app.push_navigation_stack(ActiveLidarrBlock::RootFolders.into());
-      app
-        .data
-        .lidarr_data
-        .root_folders
-        .set_items(vec![RootFolder::default()]);
-      app.data.lidarr_data.edit_root_folder = Some(HorizontallyScrollableText::default());
-
-      RootFoldersHandler::new(
-        Key::Char('a'),
-        &mut app,
-        ActiveLidarrBlock::AddRootFolderPrompt,
-        None,
-      )
-      .handle();
-
-      assert_str_eq!(
-        app.data.lidarr_data.edit_root_folder.as_ref().unwrap().text,
-        "a"
-      );
-    }
-
     #[test]
     fn test_delete_root_folder_prompt_confirm() {
       let mut app = App::test_default();
@@ -624,7 +376,9 @@ mod tests {
   #[test]
   fn test_root_folders_handler_accepts() {
     ActiveLidarrBlock::iter().for_each(|active_lidarr_block| {
-      if ROOT_FOLDERS_BLOCKS.contains(&active_lidarr_block) {
+      if ROOT_FOLDERS_BLOCKS.contains(&active_lidarr_block)
+        || ADD_ROOT_FOLDER_BLOCKS.contains(&active_lidarr_block)
+      {
         assert!(RootFoldersHandler::accepts(active_lidarr_block));
       } else {
         assert!(!RootFoldersHandler::accepts(active_lidarr_block));
@@ -671,26 +425,6 @@ mod tests {
     assert_eq!(root_folder_id, 1);
   }
 
-  #[test]
-  fn test_build_add_root_folder_body() {
-    let mut app = App::test_default();
-    app.data.lidarr_data.edit_root_folder = Some("/nfs/test".into());
-    let expected_add_root_folder_body = AddRootFolderBody {
-      path: "/nfs/test".to_owned(),
-    };
-
-    let root_folder = RootFoldersHandler::new(
-      DEFAULT_KEYBINDINGS.esc.key,
-      &mut app,
-      ActiveLidarrBlock::AddRootFolderPrompt,
-      None,
-    )
-    .build_add_root_folder_body();
-
-    assert_eq!(root_folder, expected_add_root_folder_body);
-    assert_modal_absent!(app.data.lidarr_data.edit_root_folder);
-  }
-
   #[test]
   fn test_root_folders_handler_not_ready_when_loading() {
     let mut app = App::test_default();