compliance-dashboard/src/infrastructure/findings.rs

@@ -10,48 +10,50 @@ pub struct FindingsListResponse {
     pub page: Option<u64>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct FindingsQuery {
+    pub page: u64,
+    pub severity: String,
+    pub scan_type: String,
+    pub status: String,
+    pub repo_id: String,
+    pub q: String,
+    pub sort_by: String,
+    pub sort_order: String,
+}
+
 #[server]
-#[allow(clippy::too_many_arguments)]
+pub async fn fetch_findings(query: FindingsQuery) -> Result<FindingsListResponse, ServerFnError> {
-pub async fn fetch_findings(
-    page: u64,
-    severity: String,
-    scan_type: String,
-    status: String,
-    repo_id: String,
-    q: String,
-    sort_by: String,
-    sort_order: String,
-) -> Result<FindingsListResponse, ServerFnError> {
     let state: super::server_state::ServerState =
         dioxus_fullstack::FullstackContext::extract().await?;
 
     let mut url = format!(
-        "{}/api/v1/findings?page={page}&limit=20",
+        "{}/api/v1/findings?page={}&limit=20",
-        state.agent_api_url
+        state.agent_api_url, query.page
     );
-    if !severity.is_empty() {
+    if !query.severity.is_empty() {
-        url.push_str(&format!("&severity={severity}"));
+        url.push_str(&format!("&severity={}", query.severity));
     }
-    if !scan_type.is_empty() {
+    if !query.scan_type.is_empty() {
-        url.push_str(&format!("&scan_type={scan_type}"));
+        url.push_str(&format!("&scan_type={}", query.scan_type));
     }
-    if !status.is_empty() {
+    if !query.status.is_empty() {
-        url.push_str(&format!("&status={status}"));
+        url.push_str(&format!("&status={}", query.status));
     }
-    if !repo_id.is_empty() {
+    if !query.repo_id.is_empty() {
-        url.push_str(&format!("&repo_id={repo_id}"));
+        url.push_str(&format!("&repo_id={}", query.repo_id));
     }
-    if !q.is_empty() {
+    if !query.q.is_empty() {
         url.push_str(&format!(
             "&q={}",
-            url::form_urlencoded::byte_serialize(q.as_bytes()).collect::<String>()
+            url::form_urlencoded::byte_serialize(query.q.as_bytes()).collect::<String>()
         ));
     }
-    if !sort_by.is_empty() {
+    if !query.sort_by.is_empty() {
-        url.push_str(&format!("&sort_by={sort_by}"));
+        url.push_str(&format!("&sort_by={}", query.sort_by));
     }
-    if !sort_order.is_empty() {
+    if !query.sort_order.is_empty() {
-        url.push_str(&format!("&sort_order={sort_order}"));
+        url.push_str(&format!("&sort_order={}", query.sort_order));
     }
 
     let resp = reqwest::get(&url)

compliance-dashboard/src/pages/findings.rs

@@ -24,16 +24,18 @@ pub fn FindingsPage() -> Element {
     });
 
     let mut findings = use_resource(move || {
-        let p = page();
+        let query = crate::infrastructure::findings::FindingsQuery {
-        let sev = severity_filter();
+            page: page(),
-        let typ = type_filter();
+            severity: severity_filter(),
-        let stat = status_filter();
+            scan_type: type_filter(),
-        let repo = repo_filter();
+            status: status_filter(),
-        let q = search_query();
+            repo_id: repo_filter(),
-        let sb = sort_by();
+            q: search_query(),
-        let so = sort_order();
+            sort_by: sort_by(),
+            sort_order: sort_order(),
+        };
         async move {
-            crate::infrastructure::findings::fetch_findings(p, sev, typ, stat, repo, q, sb, so)
+            crate::infrastructure::findings::fetch_findings(query)
                 .await
                 .ok()
         }