Datenbankabfrage für Benutzer aktualisieren

Cargo.toml

@@ -16,3 +16,4 @@ uuid = { version = "1.12.1", features = ["v4", "serde"] }
 tokio = { version = "1.43.0", features = ["full"] }
 thiserror = { version = "2.0.11" }
 dotenvy = "0.15.7"
+anyhow = "1.0.95"

database/Cargo.toml

@@ -11,4 +11,5 @@ serde = { workspace = true }
 uuid = { workspace = true }
 axum = { workspace = true }
 thiserror = { workspace = true }
+anyhow = { workspace = true }
 validator = { version = "0.20.0", features = ["derive"] }

database/src/model/benutzer.rs

@@ -22,7 +22,7 @@ pub struct AktualisiereBenutzer {
     pub id: Uuid,
 
     #[validate(length(min = 10, max = 255))]
-    pub email: Option<String>,
+    pub e_mail: Option<String>,
 
     #[validate(length(min = 8, max = 8))]
     pub kennung: Option<String>,
@@ -33,7 +33,7 @@ pub struct AktualisiereBenutzer {
     #[validate(length(max = 100))]
     pub vorname: Option<String>,
 
-    pub ist_akiv: Option<bool>,
+    pub ist_aktiv: Option<bool>,
 }
 
 #[derive(Debug, Deserialize)]

database/src/repository/benutzer.rs

@@ -1,6 +1,7 @@
 use crate::entity::benutzer::{self};
 use crate::error::AppError;
-use crate::model::benutzer::ErstelleBenutzer;
+use crate::model::benutzer::{AktualisiereBenutzer, ErstelleBenutzer};
+use anyhow::{Error, Result};
 use axum::Json;
 use sea_orm::{prelude::*, ActiveValue, DatabaseConnection, DbErr};
 use validator::Validate;
@@ -9,6 +10,14 @@ pub struct BenutzerRepository {
     db: DatabaseConnection,
 }
 
+macro_rules! update_if_some {
+    ($active_model:ident, $source:ident, $field:ident) => {
+        if let Some(value) = $source.$field {
+            $active_model.$field = sea_orm::ActiveValue::Set(value);
+        }
+    };
+}
+
 impl BenutzerRepository {
     pub fn new(db: DatabaseConnection) -> Self {
         Self { db }
@@ -19,6 +28,7 @@ impl BenutzerRepository {
         benutzer::Entity::find_by_id(id).one(&self.db).await
     }
 
+    // Benutzer erstellen
     pub async fn create_user(
         &self,
         Json(response): Json<ErstelleBenutzer>,
@@ -39,52 +49,33 @@ impl BenutzerRepository {
         Ok(Json(ersteller_benutzer))
     }
 
-    // // Benutzer erstellen
-    // pub async fn create_user(
-    //     &self,
-    //     kennung: String,
-    //     nachname: String,
-    //     vorname: String,
-    //     email: String,
-    // ) -> Result<benutzer::Model, DbErr> {
-    //     benutzer::ActiveModel {
-    //         id: ActiveValue::Set(uuid::Uuid::new_v4()),
-    //         kennung: ActiveValue::Set(kennung),
-    //         vorname: ActiveValue::Set(vorname),
-    //         nachname: ActiveValue::Set(nachname),
-    //         e_mail: ActiveValue::Set(email),
-    //         ..Default::default()
-    //     }
-    //     .insert(&self.db)
-    //     .await
-    // }
+    // Benutzer aktualisieren
+    pub async fn update_user(
+        &self,
+        id: uuid::Uuid,
+        response: AktualisiereBenutzer,
+    ) -> anyhow::Result<benutzer::Model, Error> {
+        response.validate()?;
 
-    // // Benutzer aktualisieren
-    // pub async fn update_user(
-    //     &self,
-    //     id: i32,
-    //     name: Option<String>,
-    //     email: Option<String>,
-    // ) -> Result<user::Model, DbErr> {
-    //     let user = user::Entity::find_by_id(id)
-    //         .one(&self.db)
-    //         .await?
-    //         .ok_or(DbErr::Custom("User not found.".to_owned()))?;
-    //
-    //     let mut user: user::ActiveModel = user.into();
-    //     if let Some(name) = name {
-    //         user.name = ActiveValue::Set(name);
-    //     }
-    //     if let Some(email) = email {
-    //         user.email = ActiveValue::Set(email);
-    //     }
-    //
-    //     user.update(&self.db).await
-    // }
-    //
-    // // Benutzer löschen
-    // pub async fn delete_user(&self, id: i32) -> Result<(), DbErr> {
-    //     user::Entity::delete_by_id(id).exec(&self.db).await?;
-    //     Ok(())
-    // }
+        let benutzer = benutzer::Entity::find_by_id(id)
+            .one(&self.db)
+            .await?
+            .ok_or(DbErr::Custom("User not found.".to_owned()))?;
+
+        let mut active_model: benutzer::ActiveModel = benutzer.into();
+
+        update_if_some!(active_model, response, e_mail);
+        update_if_some!(active_model, response, kennung);
+        update_if_some!(active_model, response, vorname);
+        update_if_some!(active_model, response, nachname);
+        update_if_some!(active_model, response, ist_aktiv);
+
+        Ok(active_model.update(&self.db).await?)
+    }
+
+    // Benutzer löschen
+    pub async fn delete_user(&self, id: uuid::Uuid) -> Result<(), Error> {
+        benutzer::Entity::delete_by_id(id).exec(&self.db).await?;
+        Ok(())
+    }
 }

main/src/main.rs

@@ -8,10 +8,7 @@ use sea_orm::Database;
 #[tokio::main]
 async fn main() -> Result<(), AppError> {
     dotenvy::dotenv().unwrap();
-    // Datenbankverbindung herstellen
-    // let root = Path::new("/");
-    // env::set_current_dir(root);
-    //
+
     let db = Database::connect(env::var("DATABASE_URL").unwrap()).await?;
 
     // Service initialisieren