backend: add route to send chargelog to a specific user.

Author: ffreddow

backend/src/api_docs.rs

@@ -106,6 +106,7 @@ async fn main() {
             routes::user::delete::delete_user,
             routes::check_expiration::check_expiration,
             routes::management::management,
+            routes::send_chargelog_to_user::send_chargelog,
         ),
         components(schemas(
             routes::auth::login::LoginSchema,
@@ -143,6 +144,7 @@ async fn main() {
             routes::check_expiration::CheckExpirationRequest,
             routes::check_expiration::TokenType,
             models::response_auth_token::ResponseAuthorizationToken,
+            routes::send_chargelog_to_user::SendChargelogSchema,
         )),
         modifiers(&JwtToken, &RefreshToken)
     )]

backend/src/routes/mod.rs

@@ -25,6 +25,7 @@ pub mod selfdestruct;
 pub mod state;
 pub mod static_files;
 pub mod user;
+pub mod send_chargelog_to_user;
 
 use actix_web::web::{self, scope};
 
@@ -37,6 +38,7 @@ pub fn configure(cfg: &mut web::ServiceConfig) {
     cfg.configure(static_files::configure);
 
     cfg.service(management::management);
+    cfg.service(send_chargelog_to_user::send_chargelog);
     cfg.service(selfdestruct::selfdestruct);
     cfg.service(check_expiration::check_expiration);
 

backend/src/routes/send_chargelog_to_user.rs

@@ -0,0 +1,113 @@
+use actix_web::{post, web, HttpRequest, HttpResponse, Responder};
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+use crate::{
+    error::Error,
+    rate_limit::ChargerRateLimiter,
+    routes::charger::add::{get_charger_from_db, password_matches},
+    utils::{parse_uuid, send_email_with_attachment},
+    AppState,
+};
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct SendChargelogSchema {
+    pub charger_uuid: String,
+    pub password: String,
+    pub user_email: String,
+    pub chargelog: Vec<u8>, // binary data
+}
+
+#[utoipa::path(
+    request_body = SendChargelogSchema,
+    responses(
+        (status = 200, description = "Chargelog sent via email"),
+        (status = 401, description = "Invalid charger credentials or rate limit exceeded"),
+        (status = 500, description = "Internal server error"),
+    )
+)]
+#[post("/send_chargelog_to_user")]
+pub async fn send_chargelog(
+    req: HttpRequest,
+    state: web::Data<AppState>,
+    rate_limiter: web::Data<ChargerRateLimiter>,
+    payload: web::Json<SendChargelogSchema>,
+) -> actix_web::Result<impl Responder> {
+    rate_limiter.check(payload.charger_uuid.clone(), &req)?;
+
+    let charger_id = parse_uuid(&payload.charger_uuid)?;
+    let charger = get_charger_from_db(charger_id, &state).await?;
+    if !password_matches(&payload.password, &charger.password)? {
+        return Err(Error::ChargerCredentialsWrong.into());
+    }
+
+    let subject = "Your Charger Log";
+    let body = "Attached is your requested chargelog.".to_string();
+    send_email_with_attachment(
+        &payload.user_email,
+        subject,
+        body,
+        payload.chargelog.clone(),
+        "chargelog.bin",
+        &state,
+    );
+
+    Ok(HttpResponse::Ok())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use actix_web::{test, App};
+    use crate::{routes::user::tests::TestUser, tests::configure};
+
+    #[actix_web::test]
+    async fn test_send_chargelog_success() {
+        let (mut user, _mail) = TestUser::random().await;
+        user.login().await;
+        let charger = user.add_random_charger().await;
+
+        let app = App::new().configure(configure).service(send_chargelog);
+        let app = test::init_service(app).await;
+
+        let payload = SendChargelogSchema {
+            charger_uuid: charger.uuid.clone(),
+            password: charger.password.clone(),
+            user_email: user.mail.clone(),
+            chargelog: vec![1, 2, 3, 4, 5],
+        };
+
+        let req = test::TestRequest::post()
+            .uri("/send_chargelog_to_user")
+            .append_header(("X-Forwarded-For", "123.123.123.3"))
+            .set_json(payload)
+            .to_request();
+        let resp = test::call_service(&app, req).await;
+        assert_eq!(resp.status(), 200);
+    }
+
+    #[actix_web::test]
+    async fn test_send_chargelog_invalid_password() {
+        let (mut user, _mail) = TestUser::random().await;
+        user.login().await;
+        let charger = user.add_random_charger().await;
+
+        let app = App::new().configure(configure).service(send_chargelog);
+        let app = test::init_service(app).await;
+
+        let payload = SendChargelogSchema {
+            charger_uuid: charger.uuid.clone(),
+            password: "wrongpassword".to_string(),
+            user_email: user.mail.clone(),
+            chargelog: vec![1, 2, 3, 4, 5],
+        };
+
+        let req = test::TestRequest::post()
+            .uri("/send_chargelog_to_user")
+            .append_header(("X-Forwarded-For", "123.123.123.3"))
+            .set_json(payload)
+            .to_request();
+        let resp = test::call_service(&app, req).await;
+        assert_eq!(resp.status(), 401);
+    }
+}

backend/src/utils.rs

@@ -194,6 +194,62 @@ pub fn send_email(email: &str, subject: &str, body: String, state: &web::Data<Ap
     }
 }
 
+/// Send an email with a binary attachment (chargelog)
+pub fn send_email_with_attachment(
+    email: &str,
+    subject: &str,
+    body: String,
+    attachment_data: Vec<u8>,
+    attachment_filename: &str,
+    state: &web::Data<AppState>,
+) {
+    #[cfg(not(test))]
+    {
+        if let Some(ref mailer) = state.mailer {
+            let multipart = lettre::message::MultiPart::mixed()
+                .singlepart(
+                    lettre::message::SinglePart::builder()
+                        .header(lettre::message::header::ContentType::TEXT_HTML)
+                        .body(body),
+                )
+                .singlepart(
+                    lettre::message::Attachment::new(attachment_filename.to_string())
+                        .body(attachment_data, lettre::message::header::ContentType::parse("application/octet-stream").unwrap()),
+                );
+
+            let email = lettre::Message::builder()
+                .from(
+                    format!("{} <{}>", state.sender_name, state.sender_email)
+                        .parse()
+                        .unwrap(),
+                )
+                .to(email.parse().unwrap())
+                .subject(subject)
+                .multipart(multipart)
+                .unwrap();
+
+            match mailer.send(&email) {
+                Ok(_) => log::info!("Email with attachment sent successfully!"),
+                Err(e) => log::error!("Could not send email: {e:?}"),
+            }
+        } else {
+            log::error!("No mailer configured, email not sent");
+        }
+    }
+
+    #[cfg(test)]
+    {
+        let _ = body;
+        let _ = state;
+        let _ = attachment_data;
+        let _ = attachment_filename;
+        println!(
+            "Test mode: Email would be sent to {} with subject '{}' and attachment {}",
+            email, subject, attachment_filename
+        );
+    }
+}
+
 pub async fn update_charger_state_change(charger_id: uuid::Uuid, state: web::Data<AppState>) {
     let Ok(mut conn) = get_connection(&state) else {
         log::error!("Failed to get database connection for updating charger state change");