hacky-ruadat/src/model/user/clubmember.rs

use super::User;
use crate::{
    model::{
        activity::ActivityBuilder, notification::Notification, role::Role, user::ManageUserUser,
    },
    special_user,
};
use rocket::async_trait;
use sqlx::SqlitePool;

special_user!(ClubMemberUser, +"Donau Linz", +"Förderndes Mitglied", +"Unterstützend");

impl ClubMemberUser {
    async fn add_membership_role(&self, db: &SqlitePool, role: &Role) {
        sqlx::query!(
            "INSERT INTO user_role(user_id, role_id) VALUES (?, ?)",
            self.id,
            role.id
        )
        .execute(db)
        .await
        .unwrap();
    }

    async fn remove_membership_role(&self, db: &SqlitePool) {
        let role = Role::find_by_name(db, "Förderndes Mitglied").await.unwrap();
        sqlx::query!(
            "DELETE FROM user_role WHERE user_id = ? and role_id = ?",
            self.id,
            role.id
        )
        .execute(db)
        .await
        .unwrap();

        let role = Role::find_by_name(db, "Unterstützend").await.unwrap();
        sqlx::query!(
            "DELETE FROM user_role WHERE user_id = ? and role_id = ?",
            self.id,
            role.id
        )
        .execute(db)
        .await
        .unwrap();

        let role = Role::find_by_name(db, "Donau Linz").await.unwrap();
        sqlx::query!(
            "DELETE FROM user_role WHERE user_id = ? and role_id = ?",
            self.id,
            role.id
        )
        .execute(db)
        .await
        .unwrap();
    }
    async fn new_membership_role(&self, db: &SqlitePool, role: &str) -> Result<(), String> {
        let role = Role::find_by_name(db, role).await.unwrap();
        self.remove_membership_role(db).await;
        self.add_membership_role(db, &role).await;
        Ok(())
    }

    pub(crate) async fn move_to_regular(
        self,
        db: &SqlitePool,
        modified_by: &ManageUserUser,
    ) -> Result<(), String> {
        if self.has_role(db, "Donau Linz").await {
            return Err(format!("User {self} ist bereits reguläres Mitglied."));
        }

        self.new_membership_role(db, "Donau Linz").await?;

        Notification::create_for_steering_people(
            db,
            &format!(
                "Liebe Steuerberechtigte, {} hat upgegraded und ist nun ein neues reguläres Mitglied. 🎉",
                self.name,
            ),
            "Neues Vereinsmitglied",
            None,
            None,
        )
        .await;

        ActivityBuilder::new(&format!(
            "{modified_by} hat {self} zu einem regulären hochgestuft."
        ))
        .relevant_for_user(&self)
        .save(db)
        .await;

        Ok(())
    }

    pub(crate) async fn move_to_unterstuetzend(
        self,
        db: &SqlitePool,
        modified_by: &ManageUserUser,
    ) -> Result<(), String> {
        if self.has_role(db, "Unterstützend").await {
            return Err(format!("User {self} ist bereits unterstützendes Mitglied."));
        }

        self.new_membership_role(db, "Unterstützend").await?;

        if let Some(vorstand) = Role::find_by_name(db, "vorstand").await {
            Notification::create_for_role(
                db,
                &vorstand,
                &format!(
                    "Lieber Vorstand, der Mitgliedstatus von {} hat sich geändert auf 'Unterstützendes Mitglied'.",
                    self.name,
                ),
                "Neues unterstützendes Vereinsmitglied",
                None,
                None,
            )
            .await;
        }

        ActivityBuilder::new(&format!(
            "{modified_by} hat {self} zu einem unterstützenden Mitglied gemacht."
        ))
        .relevant_for_user(&self)
        .save(db)
        .await;

        Ok(())
    }

    pub(crate) async fn move_to_foerdernd(
        self,
        db: &SqlitePool,
        modified_by: &ManageUserUser,
    ) -> Result<(), String> {
        if self.has_role(db, "Förderndes Mitglied").await {
            return Err(format!("User {self} ist bereits förderndes Mitglied."));
        }

        self.new_membership_role(db, "Förderndes Mitglied").await?;

        if let Some(vorstand) = Role::find_by_name(db, "vorstand").await {
            Notification::create_for_role(
                db,
                &vorstand,
                &format!(
                    "Lieber Vorstand, der Mitgliedstatus von {} hat sich geändert auf 'Förderndes Mitglied'.",
                    self.name,
                ),
                "Neues förderndes Vereinsmitglied",
                None,
                None,
            )
            .await;
        }

        ActivityBuilder::new(&format!(
            "{modified_by} hat {self} zu ein förderndes Mitglied gemacht."
        ))
        .relevant_for_user(&self)
        .save(db)
        .await;

        Ok(())
    }
}