feat: Refactor rust code

Author: stephanebouget

src-tauri/src/alerts.rs

@@ -0,0 +1,80 @@
+use tauri::Manager;
+use crate::models::{AlertsResponse, RepoAlerts, GitHubAlert};
+use crate::state::AppState;
+
+// ============================================================================
+// Security Alerts Commands
+// ============================================================================
+
+#[tauri::command]
+pub async fn get_github_security_alerts(app: tauri::AppHandle) -> Result<AlertsResponse, String> {
+    let (token, repos) = {
+        let state = app.try_state::<AppState>().ok_or("No state")?;
+        let config = state.config.lock().unwrap();
+        (
+            config.access_token.clone().ok_or("Not authenticated")?,
+            config.selected_repos.clone(),
+        )
+    };
+
+    if repos.is_empty() {
+        return Ok(AlertsResponse {
+            total_alerts: 0,
+            repos: vec![],
+        });
+    }
+
+    let mut total_alerts = 0;
+    let mut repo_alerts = Vec::new();
+    let client = reqwest::Client::new();
+
+    for repo in repos {
+        let url = format!(
+            "https://api.github.com/repos/{}/dependabot/alerts",
+            repo
+        );
+
+        match client
+            .get(&url)
+            .header("Accept", "application/vnd.github+json")
+            .header("Authorization", format!("Bearer {}", token))
+            .header("User-Agent", "github-security-alerts")
+            .send()
+            .await
+        {
+            Ok(response) => {
+                match response.json::<Vec<GitHubAlert>>().await {
+                    Ok(alerts) => {
+                        let open_alerts = alerts.iter()
+                            .filter(|a| a.state == "open")
+                            .count();
+                        total_alerts += open_alerts;
+                        repo_alerts.push(RepoAlerts {
+                            name: repo,
+                            alerts: open_alerts,
+                        });
+                    }
+                    Err(e) => {
+                        eprintln!("Failed to parse alerts for {}: {}", repo, e);
+                        repo_alerts.push(RepoAlerts {
+                            name: repo,
+                            alerts: 0,
+                        });
+                    }
+                }
+            }
+            Err(e) => {
+                eprintln!("Failed to fetch alerts for {}: {}", repo, e);
+                repo_alerts.push(RepoAlerts {
+                    name: repo,
+                    alerts: 0,
+                });
+            }
+        }
+    }
+
+    Ok(AlertsResponse {
+        total_alerts,
+        repos: repo_alerts,
+    })
+}

src-tauri/src/auth.rs

@@ -0,0 +1,94 @@
+use tauri::Manager;
+use crate::models::{AuthStatus, GitHubUser};
+use crate::state::AppState;
+use crate::config::save_config;
+
+// ============================================================================
+// Authentication Commands
+// ============================================================================
+
+/// Set a Personal Access Token directly
+#[tauri::command]
+pub async fn set_token(app: tauri::AppHandle, token: String) -> Result<(), String> {
+    // Verify token by fetching user info
+    let client = reqwest::Client::new();
+    let response = client
+        .get("https://api.github.com/user")
+        .header("Authorization", format!("Bearer {}", token))
+        .header("User-Agent", "github-security-alerts")
+        .send()
+        .await
+        .map_err(|e| format!("Failed to verify token: {}", e))?;
+
+    if !response.status().is_success() {
+        return Err("Invalid token".to_string());
+    }
+
+    // Token is valid, save it
+    if let Some(state) = app.try_state::<AppState>() {
+        let mut config = state.config.lock().unwrap();
+        config.access_token = Some(token);
+        save_config(&config)?;
+    }
+
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn get_auth_status(app: tauri::AppHandle) -> Result<AuthStatus, String> {
+    let token = {
+        let state = app.try_state::<AppState>().ok_or("No state")?;
+        let config = state.config.lock().unwrap();
+        config.access_token.clone()
+    };
+
+    match token {
+        Some(token) => {
+            // Verify token by fetching user info
+            let client = reqwest::Client::new();
+            let response = client
+                .get("https://api.github.com/user")
+                .header("Authorization", format!("Bearer {}", token))
+                .header("User-Agent", "github-security-alerts")
+                .send()
+                .await;
+
+            match response {
+                Ok(resp) if resp.status().is_success() => {
+                    let user: GitHubUser = resp.json().await.map_err(|e| e.to_string())?;
+                    Ok(AuthStatus {
+                        authenticated: true,
+                        username: Some(user.login),
+                    })
+                }
+                _ => {
+                    // Token is invalid, clear it
+                    if let Some(state) = app.try_state::<AppState>() {
+                        let mut config = state.config.lock().unwrap();
+                        config.access_token = None;
+                        let _ = save_config(&config);
+                    }
+                    Ok(AuthStatus {
+                        authenticated: false,
+                        username: None,
+                    })
+                }
+            }
+        }
+        None => Ok(AuthStatus {
+            authenticated: false,
+            username: None,
+        }),
+    }
+}
+
+#[tauri::command]
+pub async fn logout(app: tauri::AppHandle) -> Result<(), String> {
+    if let Some(state) = app.try_state::<AppState>() {
+        let mut config = state.config.lock().unwrap();
+        config.access_token = None;
+        config.selected_repos = vec![];
+        save_config(&config)?;
+    }
+    Ok(())
+}

src-tauri/src/config.rs

@@ -0,0 +1,36 @@
+use std::fs;
+use std::path::PathBuf;
+use crate::models::AppConfig;
+
+// ============================================================================
+// Config File Management
+// ============================================================================
+
+pub fn get_config_path() -> PathBuf {
+    let config_dir = dirs::config_dir()
+        .unwrap_or_else(|| PathBuf::from("."))
+        .join("github-security-alerts");
+
+    fs::create_dir_all(&config_dir).ok();
+    config_dir.join("config.json")
+}
+
+pub fn load_config() -> AppConfig {
+    let path = get_config_path();
+    if path.exists() {
+        if let Ok(content) = fs::read_to_string(&path) {
+            if let Ok(config) = serde_json::from_str(&content) {
+                return config;
+            }
+        }
+    }
+    AppConfig::default()
+}
+
+pub fn save_config(config: &AppConfig) -> Result<(), String> {
+    let path = get_config_path();
+    let content = serde_json::to_string_pretty(config)
+        .map_err(|e| e.to_string())?;
+    fs::write(path, content).map_err(|e| e.to_string())?;
+    Ok(())
+}