Clean things up a bit

src/actions/transmission.rs

@@ -1,99 +0,0 @@
-use crate::db::{Database, TransmissionProcessedTable};
-use color_eyre::eyre::{eyre, Result, WrapErr};
-use log::{debug, info, warn};
-use serde::{Deserialize, Serialize};
-use transmission_rpc::{
-    types::{BasicAuth, TorrentAddArgs},
-    TransClient,
-};
-use url::Url;
-
-/// Configuration for the Transmission action
-#[derive(Debug, Serialize, Deserialize)]
-pub struct TransmissionConfig {
-    pub enable: bool,
-    pub host: String,
-    pub username: String,
-    pub password: String,
-    pub port: u16,
-    pub download_dir: String,
-}
-
-/// Action for submitting magnet links to Transmission
-pub struct TransmissionAction {
-    client: TransClient,
-    download_dir: String,
-    db: Database,
-}
-
-impl TransmissionAction {
-    pub async fn new(config: &TransmissionConfig, db: Database) -> Result<Self> {
-        if !config.enable {
-            return Err(eyre!("Transmission action is disabled"));
-        }
-
-        let url_str = format!("{}:{}/transmission/rpc", config.host, config.port);
-        let url = Url::parse(&url_str).wrap_err_with(|| format!("Invalid URL: {}", url_str))?;
-
-        let auth = BasicAuth {
-            user: config.username.clone(),
-            password: config.password.clone(),
-        };
-
-        let client = TransClient::with_auth(url, auth);
-
-        Ok(TransmissionAction {
-            client,
-            download_dir: config.download_dir.clone(),
-            db,
-        })
-    }
-
-    /// Process all unprocessed magnet links
-    pub async fn process_unprocessed_magnets(&mut self) -> Result<usize> {
-        let unprocessed_magnets = self
-            .db
-            .get_unprocessed_magnets_for_table::<TransmissionProcessedTable>()?;
-        let mut processed_count = 0;
-
-        for magnet in unprocessed_magnets {
-            if let Some(id) = magnet.id {
-                match self.submit_magnet(&magnet.link).await {
-                    Ok(_) => {
-                        info!(
-                            "Successfully submitted magnet link to Transmission: {}",
-                            magnet.title
-                        );
-                        debug!("Magnet link: {}", magnet.link);
-                        self.db
-                            .mark_magnet_processed_for_table::<TransmissionProcessedTable>(id)?;
-                        processed_count += 1;
-                    }
-                    Err(e) => {
-                        warn!("Failed to submit magnet link to Transmission: {}", e);
-                    }
-                }
-            } else {
-                warn!("Skipping magnet with null ID: {}", magnet.link);
-            }
-        }
-
-        Ok(processed_count)
-    }
-
-    /// Submit a magnet link to Transmission
-    async fn submit_magnet(&mut self, magnet: &str) -> Result<()> {
-        let args = TorrentAddArgs {
-            filename: Some(magnet.to_string()),
-            download_dir: Some(self.download_dir.clone()),
-            ..Default::default()
-        };
-
-        self.client
-            .torrent_add(args)
-            .await
-            .map_err(|e| eyre!("Failed to add torrent to Transmission: {}", e))?;
-
-        Ok(())
-    }
-}

src/actions/transmission/action.rs

@@ -0,0 +1,51 @@
+use crate::actions::transmission::client::TransmissionClient;
+use crate::actions::transmission::config::TransmissionConfig;
+use crate::db::{Database, TransmissionProcessedTable};
+use color_eyre::eyre::Result;
+use log::{debug, info, warn};
+
+/// Action for submitting magnet links to Transmission
+pub struct TransmissionAction {
+    client: TransmissionClient,
+    db: Database,
+}
+
+impl TransmissionAction {
+    pub async fn new(config: &TransmissionConfig, db: Database) -> Result<Self> {
+        let client = TransmissionClient::new(config)?;
+
+        Ok(TransmissionAction { client, db })
+    }
+
+    /// Process all unprocessed magnet links
+    pub async fn process_unprocessed_magnets(&mut self) -> Result<usize> {
+        let unprocessed_magnets = self
+            .db
+            .get_unprocessed_magnets_for_table::<TransmissionProcessedTable>()?;
+        let mut processed_count = 0;
+
+        for magnet in unprocessed_magnets {
+            if let Some(id) = magnet.id {
+                match self.client.submit_magnet(&magnet.link).await {
+                    Ok(_) => {
+                        info!(
+                            "Successfully submitted magnet link to Transmission: {}",
+                            magnet.title
+                        );
+                        debug!("Magnet link: {}", magnet.link);
+                        self.db
+                            .mark_magnet_processed_for_table::<TransmissionProcessedTable>(id)?;
+                        processed_count += 1;
+                    }
+                    Err(e) => {
+                        warn!("Failed to submit magnet link to Transmission: {}", e);
+                    }
+                }
+            } else {
+                warn!("Skipping magnet with null ID: {}", magnet.link);
+            }
+        }
+
+        Ok(processed_count)
+    }
+}

src/actions/transmission/client.rs

@@ -0,0 +1,53 @@
+use crate::actions::transmission::config::TransmissionConfig;
+use color_eyre::eyre::{eyre, Result, WrapErr};
+use transmission_rpc::{
+    types::{BasicAuth, TorrentAddArgs},
+    TransClient,
+};
+use url::Url;
+
+/// High-level Transmission client
+pub struct TransmissionClient {
+    client: TransClient,
+    download_dir: String,
+}
+
+impl TransmissionClient {
+    /// Create a new Transmission client from configuration
+    pub fn new(config: &TransmissionConfig) -> Result<Self> {
+        if !config.enable {
+            return Err(eyre!("Transmission action is disabled"));
+        }
+
+        let url_str = format!("{}:{}/transmission/rpc", config.host, config.port);
+        let url = Url::parse(&url_str).wrap_err_with(|| format!("Invalid URL: {}", url_str))?;
+
+        let auth = BasicAuth {
+            user: config.username.clone(),
+            password: config.password.clone(),
+        };
+
+        let client = TransClient::with_auth(url, auth);
+
+        Ok(TransmissionClient {
+            client,
+            download_dir: config.download_dir.clone(),
+        })
+    }
+
+    /// Submit a magnet link to Transmission
+    pub async fn submit_magnet(&mut self, magnet: &str) -> Result<()> {
+        let args = TorrentAddArgs {
+            filename: Some(magnet.to_string()),
+            download_dir: Some(self.download_dir.clone()),
+            ..Default::default()
+        };
+
+        self.client
+            .torrent_add(args)
+            .await
+            .map_err(|e| eyre!("Failed to add torrent to Transmission: {}", e))?;
+
+        Ok(())
+    }
+}

src/actions/transmission/config.rs

@@ -0,0 +1,12 @@
+use serde::{Deserialize, Serialize};
+
+/// Configuration for the Transmission action
+#[derive(Debug, Serialize, Deserialize)]
+pub struct TransmissionConfig {
+    pub enable: bool,
+    pub host: String,
+    pub username: String,
+    pub password: String,
+    pub port: u16,
+    pub download_dir: String,
+}

src/actions/transmission/mod.rs

@@ -0,0 +1,6 @@
+pub mod action;
+pub mod client;
+pub mod config;
+
+pub use action::TransmissionAction;
+pub use config::TransmissionConfig;