Clean things up a bit

src/app.rs

@@ -0,0 +1,244 @@
+use crate::actions::action::{Action, ProcessedMagnets};
+use crate::actions::bitmagnet::BitmagnetAction;
+use crate::actions::factory::init_action;
+use crate::actions::transmission::TransmissionAction;
+use crate::config::Config;
+use crate::db::Database;
+use crate::notifications::factory::init_notification;
+use crate::notifications::notification::Notification;
+use crate::notifications::ntfy::NtfyNotification;
+use crate::reddit_client::{RedditClient, RedditPost};
+use crate::report;
+use color_eyre::eyre::{Result, WrapErr};
+use log::{debug, info, warn};
+use multimap::MultiMap;
+use regex::Regex;
+use std::collections::{HashMap, HashSet};
+
+/// Trait for configurations that can be enabled or disabled
+pub trait Enableable {
+    /// Returns whether the configuration is enabled
+    fn is_enabled(&self) -> bool;
+}
+
+/// Application state and behavior
+pub struct App {
+    db: Database,
+    config: Config,
+    actions: Vec<Box<dyn Action>>,
+    notifications: Vec<Box<dyn Notification>>,
+    reddit_client: RedditClient,
+}
+
+impl App {
+    /// Create a new App instance
+    pub fn new(db: Database, config: Config) -> Self {
+        Self {
+            db,
+            config,
+            actions: Vec::new(),
+            notifications: Vec::new(),
+            reddit_client: RedditClient::new(),
+        }
+    }
+
+    /// Initialize actions based on configuration
+    pub fn init_actions(&mut self) -> Result<()> {
+        if let Some(action) = init_action(&mut &self.config.bitmagnet, BitmagnetAction::new)? {
+            self.actions.push(action);
+        }
+        if let Some(action) = init_action(&mut &self.config.transmission, TransmissionAction::new)?
+        {
+            self.actions.push(action);
+        }
+
+        Ok(())
+    }
+
+    /// Initialize notifications based on configuration
+    pub fn init_notifications(&mut self) -> Result<()> {
+        if let Some(notification) = init_notification(&self.config.ntfy, NtfyNotification::new)? {
+            self.notifications.push(notification);
+        }
+
+        Ok(())
+    }
+
+    /// Fetch posts from Reddit
+    pub async fn fetch_posts(&self, post_count: u32) -> Result<MultiMap<String, RedditPost>> {
+        let mut unique_usernames = HashSet::new();
+        for (_, source_config) in &self.config.sources {
+            unique_usernames.insert(source_config.username.clone());
+        }
+
+        let mut user_posts = MultiMap::new();
+        for username in unique_usernames {
+            info!("Fetching posts from user [{}]", username);
+            let submissions = self
+                .reddit_client
+                .fetch_user_submissions(&username, post_count)
+                .await?;
+            user_posts.insert_many(username, submissions);
+        }
+
+        Ok(user_posts)
+    }
+
+    /// Process sources and extract magnet links
+    pub async fn process_sources(
+        &mut self,
+        user_posts: &MultiMap<String, RedditPost>,
+    ) -> Result<usize> {
+        let mut total_new_links = 0;
+
+        for (source_name, source_config) in &self.config.sources {
+            info!("Processing source [{}]", source_name);
+
+            let username = source_config.username.clone();
+            let title_filter = match &source_config.title_filter {
+                Some(filter) => Some(
+                    Regex::new(filter.as_str())
+                        .context(format!("Invalid regex pattern: {}", filter))?,
+                ),
+                None => None,
+            };
+
+            if let Some(submissions) = user_posts.get_vec(&username) {
+                for post in submissions
+                    .iter()
+                    .filter(|s| filter_post(&s.title, title_filter.clone()))
+                {
+                    let title = &post.title;
+                    let body = &post.body;
+                    let subreddit = &post.subreddit;
+
+                    let magnet_links = crate::magnet::extract_magnet_links(body);
+                    if !magnet_links.is_empty() {
+                        let post_info = crate::PostInfo {
+                            title: title.to_string(),
+                            submitter: username.clone(),
+                            subreddit: subreddit.to_string(),
+                            magnet_links,
+                            timestamp: post.created,
+                            imdb_id: source_config.imdb_id.clone(),
+                        };
+
+                        // Store the post info in the database
+                        match self.db.store_magnets(&post_info) {
+                            Ok(count) => {
+                                total_new_links += count;
+                            }
+                            Err(e) => {
+                                warn!("Failed to store post info in database: {}", e);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(total_new_links)
+    }
+
+    /// Process magnet links with actions
+    pub async fn process_actions(&mut self) -> Result<HashMap<String, ProcessedMagnets>> {
+        let mut action_results = HashMap::new();
+
+        for action in &mut self.actions {
+            debug!("Processing magnet links with {}", action.get_name());
+
+            match action.process_unprocessed_magnets(&mut self.db).await {
+                Ok(processed_magnets) => {
+                    let count = processed_magnets.success.len();
+                    debug!(
+                        "Successfully processed {} magnet links with {}",
+                        count,
+                        action.get_name()
+                    );
+                    action_results.insert(action.get_name().to_string(), processed_magnets);
+                }
+                Err(e) => {
+                    warn!(
+                        "Failed to process magnet links with {}: {}",
+                        action.get_name(),
+                        e
+                    );
+                }
+            }
+        }
+
+        Ok(action_results)
+    }
+
+    /// Send notifications
+    pub async fn send_notifications(
+        &self,
+        action_results: &HashMap<String, ProcessedMagnets>,
+        total_new_links: usize,
+    ) -> Result<()> {
+        for notification in &self.notifications {
+            match notification
+                .send_notification(action_results, total_new_links)
+                .await
+            {
+                Ok(_) => {
+                    debug!(
+                        "Successfully sent notification to {}",
+                        notification.get_name()
+                    );
+                }
+                Err(e) => {
+                    warn!(
+                        "Failed to send notification to {}: {}",
+                        notification.get_name(),
+                        e
+                    );
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Generate and display report
+    pub fn generate_report(
+        &self,
+        action_results: &HashMap<String, ProcessedMagnets>,
+        total_new_links: usize,
+    ) {
+        for line in report::generate_report(action_results, total_new_links, true).lines() {
+            info!("{}", line);
+        }
+    }
+
+    pub async fn run(&mut self, post_count: u32) -> Result<()> {
+        self.init_actions()?;
+        self.init_notifications()?;
+
+        // Fetch posts from Reddit
+        let user_posts = self.fetch_posts(post_count).await?;
+
+        // Process sources and extract magnet links
+        let total_new_links = self.process_sources(&user_posts).await?;
+
+        // Process magnet links with actions
+        let action_results = self.process_actions().await?;
+
+        // Send notifications
+        self.send_notifications(&action_results, total_new_links)
+            .await?;
+
+        // Generate and display report
+        self.generate_report(&action_results, total_new_links);
+
+        Ok(())
+    }
+}
+
+/// Filters posts based on a title filter pattern
+fn filter_post(title: &str, title_filter: Option<Regex>) -> bool {
+    match title_filter {
+        Some(pattern) => pattern.is_match(title),
+        None => true,
+    }
+}