be able to update data individually; Fixes #951

src/model/user/basic.rs

@@ -0,0 +1,199 @@
+// TODO: put back in `src/model/user/mod.rs` once that is cleaned up
+
+use super::{AllowedToEditPaymentStatusUser, ManageUserUser, User};
+use crate::model::{log::Log, mail::valid_mails, role::Role};
+use sqlx::SqlitePool;
+
+impl User {
+    pub(crate) async fn update_mail(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        new_mail: &str,
+    ) -> Result<(), String> {
+        let new_mail = new_mail.trim();
+
+        if !valid_mails(new_mail) {
+            return Err(format!(
+                "{new_mail} ist kein gültiges Format für eine Mailadresse"
+            ));
+        }
+
+        sqlx::query!("UPDATE user SET mail = ? where id = ?", new_mail, self.id)
+            .execute(db)
+            .await
+            .unwrap(); //Okay, because we can only create a User of a valid id
+
+        let msg = match &self.mail {
+            Some(old_mail) => format!(
+                "{updated_by} has changed the mail address of {self} from {old_mail} to {new_mail}"
+            ),
+            None => format!("{updated_by} has added a mail address for {self}: {new_mail}"),
+        };
+        Log::create(db, msg).await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn update_phone(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        new_phone: &str,
+    ) -> Result<(), String> {
+        let new_phone = new_phone.trim();
+
+        let query = if new_phone.is_empty() {
+            sqlx::query!("UPDATE user SET phone = NULL where id = ?", self.id)
+        } else {
+            sqlx::query!("UPDATE user SET phone = ? where id = ?", new_phone, self.id)
+        };
+        query.execute(db).await.unwrap(); //Okay, because we can only create a User of a valid id
+
+        let msg = match &self.phone {
+            Some(old_phone) if new_phone.is_empty() => format!("{updated_by} has removed the phone number of {self} (old number: {old_phone})"),
+            Some(old_phone) => format!("{updated_by} has changed the phone number of {self} from {old_phone} to {new_phone}"),
+            None => format!("{updated_by} has added a phone number for {self}: {new_phone}")
+        };
+        Log::create(db, msg).await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn update_nickname(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        new_nickname: &str,
+    ) -> Result<(), String> {
+        let new_nickname = new_nickname.trim();
+
+        let query = if new_nickname.is_empty() {
+            sqlx::query!("UPDATE user SET nickname = NULL where id = ?", self.id)
+        } else {
+            sqlx::query!(
+                "UPDATE user SET nickname = ? where id = ?",
+                new_nickname,
+                self.id
+            )
+        };
+        query.execute(db).await.unwrap(); //Okay, because we can only create a User of a valid id
+
+        let msg = match &self.nickname {
+            Some(old_nickname) if new_nickname.is_empty() => format!("{updated_by} has removed the nickname of {self} (old nickname: {old_nickname})"),
+            Some(old_nickname) => format!("{updated_by} has changed the nickname of {self} from {old_nickname} to {new_nickname}"),
+            None => format!("{updated_by} has added a nickname for {self}: {new_nickname}")
+        };
+        Log::create(db, msg).await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn remove_role(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        role: &Role,
+    ) -> Result<(), String> {
+        if !self.has_role(db, &role.name).await {
+            return Err(format!("Kann Rolle {role} von User {self} nicht entfernen, da der User die Rolle gar nicht hat"));
+        }
+
+        sqlx::query!(
+            "DELETE FROM user_role WHERE user_id = ? and role_id = ?",
+            self.id,
+            role.id
+        )
+        .execute(db)
+        .await
+        .unwrap();
+
+        Log::create(
+            db,
+            format!("{updated_by} has removed role {role} from user {self}"),
+        )
+        .await;
+
+        Ok(())
+    }
+
+    pub(crate) async fn has_not_paid(
+        &self,
+        db: &SqlitePool,
+        updated_by: &AllowedToEditPaymentStatusUser,
+    ) {
+        let paid = Role::find_by_name(db, "paid").await.unwrap();
+
+        sqlx::query!(
+            "DELETE FROM user_role WHERE user_id = ? and role_id = ?",
+            self.id,
+            paid.id
+        )
+        .execute(db)
+        .await
+        .unwrap();
+
+        Log::create(
+            db,
+            format!("{updated_by} has set that user {self} has NOT paid the fee (yet)"),
+        )
+        .await;
+    }
+    pub(crate) async fn has_paid(
+        &self,
+        db: &SqlitePool,
+        updated_by: &AllowedToEditPaymentStatusUser,
+    ) {
+        let paid = Role::find_by_name(db, "paid").await.unwrap();
+
+        sqlx::query!(
+            "INSERT INTO user_role(user_id, role_id) VALUES (?, ?)",
+            self.id,
+            paid.id
+        )
+        .execute(db)
+        .await
+        .expect("paid role has no group");
+
+        Log::create(
+            db,
+            format!("{updated_by} has set that user {self} has paid the fee (yet)"),
+        )
+        .await;
+    }
+
+    pub(crate) async fn add_role(
+        &self,
+        db: &SqlitePool,
+        updated_by: &ManageUserUser,
+        role: &Role,
+    ) -> Result<(), String> {
+        if self.has_role(db, &role.name).await {
+            return Err(format!("Kann Rolle {role} von User {self} nicht hinzufügen, da der User die Rolle schon hat"));
+        }
+
+        sqlx::query!(
+            "INSERT INTO user_role(user_id, role_id) VALUES (?, ?)",
+            self.id,
+            role.id
+        )
+        .execute(db)
+        .await
+        .map_err(|_| {
+            format!(
+                "User already has a role in the cluster '{}'",
+                role.cluster
+                    .clone()
+                    .expect("db trigger can't activate on empty string")
+            )
+        })?;
+
+        Log::create(
+            db,
+            format!("{updated_by} has added role {role} to user {self}"),
+        )
+        .await;
+
+        Ok(())
+    }
+}