List devices API working

backend/src/web_server.rs

@@ -1,7 +1,13 @@
-use std::error::Error;
+use std::{collections::HashMap, error::Error};
 
-use axum::{Json, Router, extract::Path, http::StatusCode, routing::get};
-use log::{debug, error, info};
+use axum::{
+    Json, Router,
+    extract::{Path, Query},
+    http::StatusCode,
+    routing::get,
+};
+use chrono::{DateTime, Utc};
+use log::{debug, error, info, warn};
 use tower_http::services::ServeDir;
 
 use crate::{
@@ -15,7 +21,7 @@ pub async fn serve() -> Result<(), Box<dyn Error>> {
 
     let router = Router::new()
         .route("/", get(|| async { "hello" }))
-        .route("/api/devices", get(get_devices))
+        .route("/api/devices", get(list_devices))
         .route("/api/notifications", get(list_notifications))
         .route("/api/notifications/{id}", get(read_notification))
         .route(
@@ -33,8 +39,75 @@ pub async fn serve() -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
-async fn get_devices() -> Result<Json<Vec<Device>>, StatusCode> {
-    unimplemented!();
+fn parse_parameter_bool(params: &HashMap<String, String>, name: &str) -> Option<bool> {
+    if params.contains_key(name) {
+        let param_value = params.get(name).unwrap().as_str();
+        debug!("Found parameter {name} with value {}", param_value);
+        match param_value.parse::<bool>() {
+            Ok(value) => Some(value),
+            Err(_) => None,
+        }
+    } else {
+        None
+    }
+}
+
+fn parse_parameter_string(params: &HashMap<String, String>, name: &str) -> Option<String> {
+    if params.contains_key(name) {
+        let param_value = params.get(name).unwrap().as_str();
+        debug!("Found parameter {name} with value {}", param_value);
+        Some(param_value.to_string())
+    } else {
+        None
+    }
+}
+
+fn parse_parameter_date(params: &HashMap<String, String>, name: &str) -> Option<DateTime<Utc>> {
+    if params.contains_key(name) {
+        let mut param_value = params.get(name).unwrap().to_ascii_uppercase();
+        if !param_value.ends_with("Z") {
+            param_value.push('Z');
+        }
+        debug!("Found parameter {name} with value {}", param_value);
+        match DateTime::parse_from_rfc3339(param_value.as_str()) {
+            Ok(value) => {
+                debug!("Date parsed to {}", value.to_utc().to_rfc3339());
+                Some(value.to_utc())
+            }
+            Err(err) => {
+                warn!("Error parsing date from parameters: {}", err);
+                None
+            }
+        }
+    } else {
+        None
+    }
+}
+
+async fn list_devices(
+    Query(params): Query<HashMap<String, String>>,
+) -> Result<Json<Vec<Device>>, StatusCode> {
+    let is_registered: Option<bool> = parse_parameter_bool(&params, "is_registered");
+    let last_seen_from: Option<DateTime<Utc>> = parse_parameter_date(&params, "last_seen_from");
+    let last_seen_to: Option<DateTime<Utc>> = parse_parameter_date(&params, "last_seen_to");
+    let owner: Option<String> = parse_parameter_string(&params, "owner");
+    let device_type: Option<String> = parse_parameter_string(&params, "device_type");
+    let vendor: Option<String> = parse_parameter_string(&params, "vendor");
+
+    match db::devices::list_devices(
+        is_registered,
+        last_seen_from,
+        last_seen_to,
+        owner,
+        device_type,
+        vendor,
+    ) {
+        Ok(value) => Ok(Json(value)),
+        Err(err) => {
+            error!("Error listing devices: {}", err);
+            Err(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
 }
 
 async fn read_notification(Path(id): Path<i64>) -> Result<Json<Notification>, StatusCode> {