feat: findings refinement, new scanners, and deployment tooling (#6)

compliance-dashboard/src/pages/findings.rs

@@ -12,6 +12,10 @@ pub fn FindingsPage() -> Element {
     let mut type_filter = use_signal(String::new);
     let mut status_filter = use_signal(String::new);
     let mut repo_filter = use_signal(String::new);
+    let mut search_query = use_signal(String::new);
+    let mut sort_by = use_signal(|| "created_at".to_string());
+    let mut sort_order = use_signal(|| "desc".to_string());
+    let mut selected_ids = use_signal(Vec::<String>::new);
 
     let repos = use_resource(|| async {
         crate::infrastructure::repositories::fetch_repositories(1)
@@ -19,19 +23,52 @@ pub fn FindingsPage() -> Element {
             .ok()
     });
 
-    let findings = use_resource(move || {
-        let p = page();
-        let sev = severity_filter();
-        let typ = type_filter();
-        let stat = status_filter();
-        let repo = repo_filter();
+    let mut findings = use_resource(move || {
+        let query = crate::infrastructure::findings::FindingsQuery {
+            page: page(),
+            severity: severity_filter(),
+            scan_type: type_filter(),
+            status: status_filter(),
+            repo_id: repo_filter(),
+            q: search_query(),
+            sort_by: sort_by(),
+            sort_order: sort_order(),
+        };
         async move {
-            crate::infrastructure::findings::fetch_findings(p, sev, typ, stat, repo)
+            crate::infrastructure::findings::fetch_findings(query)
                 .await
                 .ok()
         }
     });
 
+    let toggle_sort = move |field: &'static str| {
+        move |_: MouseEvent| {
+            if sort_by() == field {
+                sort_order.set(if sort_order() == "asc" {
+                    "desc".to_string()
+                } else {
+                    "asc".to_string()
+                });
+            } else {
+                sort_by.set(field.to_string());
+                sort_order.set("desc".to_string());
+            }
+            page.set(1);
+        }
+    };
+
+    let sort_indicator = move |field: &str| -> String {
+        if sort_by() == field {
+            if sort_order() == "asc" {
+                " \u{25B2}".to_string()
+            } else {
+                " \u{25BC}".to_string()
+            }
+        } else {
+            String::new()
+        }
+    };
+
     rsx! {
         PageHeader {
             title: "Findings",
@@ -39,6 +76,12 @@ pub fn FindingsPage() -> Element {
         }
 
         div { class: "filter-bar",
+            input {
+                r#type: "text",
+                placeholder: "Search findings...",
+                style: "min-width: 200px;",
+                oninput: move |e| { search_query.set(e.value()); page.set(1); },
+            }
             select {
                 onchange: move |e| { repo_filter.set(e.value()); page.set(1); },
                 option { value: "", "All Repositories" }
@@ -76,6 +119,9 @@ pub fn FindingsPage() -> Element {
                 option { value: "cve", "CVE" }
                 option { value: "gdpr", "GDPR" }
                 option { value: "oauth", "OAuth" }
+                option { value: "secret_detection", "Secrets" }
+                option { value: "lint", "Lint" }
+                option { value: "code_review", "Code Review" }
             }
             select {
                 onchange: move |e| { status_filter.set(e.value()); page.set(1); },
@@ -88,29 +134,124 @@ pub fn FindingsPage() -> Element {
             }
         }
 
+        // Bulk action bar
+        if !selected_ids().is_empty() {
+            div {
+                class: "card",
+                style: "display: flex; align-items: center; gap: 12px; padding: 12px 16px; margin-bottom: 16px; background: rgba(56, 189, 248, 0.08); border-color: rgba(56, 189, 248, 0.2);",
+                span {
+                    style: "font-size: 14px; color: var(--text-secondary);",
+                    "{selected_ids().len()} selected"
+                }
+                for status in ["triaged", "resolved", "false_positive", "ignored"] {
+                    {
+                        let status_str = status.to_string();
+                        let label = match status {
+                            "false_positive" => "False Positive",
+                            other => {
+                                // Capitalize first letter
+                                let mut s = other.to_string();
+                                if let Some(c) = s.get_mut(0..1) { c.make_ascii_uppercase(); }
+                                // Leak to get a &str that lives long enough - this is fine for static-ish UI strings
+                                &*Box::leak(s.into_boxed_str())
+                            }
+                        };
+                        rsx! {
+                            button {
+                                class: "btn btn-sm btn-ghost",
+                                onclick: move |_| {
+                                    let ids = selected_ids();
+                                    let s = status_str.clone();
+                                    spawn(async move {
+                                        let _ = crate::infrastructure::findings::bulk_update_finding_status(ids, s).await;
+                                        findings.restart();
+                                    });
+                                    selected_ids.set(Vec::new());
+                                },
+                                "Mark {label}"
+                            }
+                        }
+                    }
+                }
+                button {
+                    class: "btn btn-sm btn-ghost",
+                    onclick: move |_| { selected_ids.set(Vec::new()); },
+                    "Clear"
+                }
+            }
+        }
+
         match &*findings.read() {
             Some(Some(resp)) => {
                 let total_pages = resp.total.unwrap_or(0).div_ceil(20).max(1);
+                let all_ids: Vec<String> = resp.data.iter().filter_map(|f| f.id.as_ref().map(|id| id.to_hex())).collect();
                 rsx! {
                     div { class: "card",
                         div { class: "table-wrapper",
                             table {
                                 thead {
                                     tr {
-                                        th { "Severity" }
-                                        th { "Title" }
-                                        th { "Type" }
+                                        th {
+                                            style: "width: 40px;",
+                                            input {
+                                                r#type: "checkbox",
+                                                checked: !all_ids.is_empty() && selected_ids().len() == all_ids.len(),
+                                                onchange: move |_| {
+                                                    if selected_ids().len() == all_ids.len() {
+                                                        selected_ids.set(Vec::new());
+                                                    } else {
+                                                        selected_ids.set(all_ids.clone());
+                                                    }
+                                                },
+                                            }
+                                        }
+                                        th {
+                                            style: "cursor: pointer; user-select: none;",
+                                            onclick: toggle_sort("severity"),
+                                            "Severity{sort_indicator(\"severity\")}"
+                                        }
+                                        th {
+                                            style: "cursor: pointer; user-select: none;",
+                                            onclick: toggle_sort("title"),
+                                            "Title{sort_indicator(\"title\")}"
+                                        }
+                                        th {
+                                            style: "cursor: pointer; user-select: none;",
+                                            onclick: toggle_sort("scan_type"),
+                                            "Type{sort_indicator(\"scan_type\")}"
+                                        }
                                         th { "Scanner" }
                                         th { "File" }
-                                        th { "Status" }
+                                        th {
+                                            style: "cursor: pointer; user-select: none;",
+                                            onclick: toggle_sort("status"),
+                                            "Status{sort_indicator(\"status\")}"
+                                        }
                                     }
                                 }
                                 tbody {
                                     for finding in &resp.data {
                                         {
                                             let id = finding.id.as_ref().map(|id| id.to_hex()).unwrap_or_default();
+                                            let id_for_check = id.clone();
+                                            let is_selected = selected_ids().contains(&id);
                                             rsx! {
                                                 tr {
+                                                    td {
+                                                        input {
+                                                            r#type: "checkbox",
+                                                            checked: is_selected,
+                                                            onchange: move |_| {
+                                                                let mut ids = selected_ids();
+                                                                if ids.contains(&id_for_check) {
+                                                                    ids.retain(|i| i != &id_for_check);
+                                                                } else {
+                                                                    ids.push(id_for_check.clone());
+                                                                }
+                                                                selected_ids.set(ids);
+                                                            },
+                                                        }
+                                                    }
                                                     td { SeverityBadge { severity: finding.severity.to_string() } }
                                                     td {
                                                         Link {