use crate::core::sensors_analyzer::SensorReading;
use crate::security::jwt::JwtManager;
use crate::AppState;
use actix_web::{dev::Payload, FromRequest};
use actix_web::{post, web, HttpRequest, HttpResponse, Responder};
use serde::Deserialize;
use std::future::{ready, Ready};
#[derive(Deserialize)]
pub struct SensorsAnalyzeRequest {
pub reading: SensorReading, pub history: Vec<SensorReading>, }
pub struct BearerToken(pub String);
impl FromRequest for BearerToken {
type Error = actix_web::Error;
type Future = Ready<Result<Self, Self::Error>>;
fn from_request(req: &HttpRequest, _payload: &mut Payload) -> Self::Future {
let token = req
.headers()
.get("Authorization")
.and_then(|hv| hv.to_str().ok())
.map(|s| s.trim_start_matches("Bearer ").to_string())
.unwrap_or_default();
ready(Ok(Self(token)))
}
}
#[post("/sensors/analyze")]
pub async fn analyze_sensors(
app_data: web::Data<AppState>,
payload: web::Json<SensorsAnalyzeRequest>,
bearer: BearerToken,
) -> impl Responder {
let token = bearer.0;
if token.is_empty() {
return HttpResponse::Unauthorized().body("Missing Authorization token");
}
let jwt_manager = JwtManager::new(
&crate::security::secret::SecureString::new(
"a_very_secure_and_long_secret_key_that_is_at_least_32_bytes_long".to_string(),
),
60,
"my_app".to_string(),
"user_service".to_string(),
);
if jwt_manager.decode_token(&token).is_err() {
return HttpResponse::Unauthorized().body("Invalid or expired token");
}
let engine = &app_data.x_engine.sensors_engine;
match engine
.analyze(payload.reading.clone(), &payload.history)
.await
{
Ok(result) => HttpResponse::Ok().json(result), Err(e) => HttpResponse::InternalServerError().json(e.to_string()), }
}