rowt/src/model/user/schnupperant.rs

use super::foerdernd::FoerderndUser;
use super::regular::RegularUser;
use super::scheckbuch::ScheckbuchUser;
use super::schnupperinterest::SchnupperInterestUser;
use super::unterstuetzend::UnterstuetzendUser;
use super::{ManageUserUser, User};
use crate::model::activity::ActivityBuilder;
use crate::model::role::Role;
use crate::NonEmptyString;
use crate::{
    model::{mail::Mail, notification::Notification},
    special_user,
};
use chrono::NaiveDate;
use rocket::async_trait;
use rocket::fs::TempFile;
use sqlx::SqlitePool;

special_user!(SchnupperantUser, +"schnupperant");

impl SchnupperantUser {
    async fn set_data_for_clubmember(
        &self,
        db: &SqlitePool,
        changed_by: &ManageUserUser,
        member_since: &NaiveDate,
        birthdate: &NaiveDate,
        phone: NonEmptyString,
        address: NonEmptyString,
        membership_pdf: &TempFile<'_>,
    ) -> Result<(), String> {
        self.user.update_birthdate(db, changed_by, birthdate).await;
        self.user
            .update_member_since(db, changed_by, member_since)
            .await;

        self.user.update_phone(db, changed_by, &phone).await;
        self.user.update_address(db, changed_by, &address).await;
        self.user
            .add_membership_pdf(db, changed_by, membership_pdf)
            .await?;

        Ok(())
    }
    pub(crate) async fn convert_to_regular_user(
        self,
        db: &SqlitePool,
        smtp_pw: &str,
        changed_by: &ManageUserUser,
        member_since: &NaiveDate,
        birthdate: &NaiveDate,
        phone: NonEmptyString,
        address: NonEmptyString,
        membership_pdf: &TempFile<'_>,
    ) -> Result<(), String> {
        self.set_data_for_clubmember(
            db,
            changed_by,
            member_since,
            birthdate,
            phone,
            address,
            membership_pdf,
        )
        .await?;

        // Change roles
        let paid = Role::find_by_name(db, "paid").await.unwrap();
        if self.user.remove_role(db, changed_by, &paid).await.is_err() {
            self.remove_membership_pdf(db, changed_by).await;
            return Err("Kann noch kein normales Mitglied werden, da die Schnupperkurs-Gebühr noch nicht bezahlt wurde.".into());
        }
        let scheckbook = Role::find_by_name(db, "schnupperant").await.unwrap();
        self.user.remove_role(db, changed_by, &scheckbook).await?;

        let regular = Role::find_by_name(db, "Donau Linz").await.unwrap();
        self.user.add_role(db, changed_by, &regular).await?;

        let participated_schnupperkurs = Role::find_by_name(db, "participated_schnupperkurs")
            .await
            .unwrap();
        self.user
            .add_role(db, changed_by, &participated_schnupperkurs)
            .await?;

        // Notify
        let regular = RegularUser::new(db, &self.user).await.unwrap();
        regular.send_welcome_mail_to_user(db, smtp_pw).await?;
        Notification::create_for_steering_people(
            db,
            &format!(
                "Liebe Steuerberechtigte, {} nahm an unserem Schnupperkurs teil und ist nun seit {member_since} ein neues reguläres Mitglied. 🎉",
                self.name
            ),
            "Neues Vereinsmitglied",
            None,
            None,
        )
        .await;

        ActivityBuilder::new(&format!(
            "{changed_by} hat den Schnupperant {self} auf ein reguläres Mitglied upgegraded!"
        ))
        .relevant_for_user(&self)
        .save(db)
        .await;

        Ok(())
    }

    pub(crate) async fn move_to_scheckbook(
        self,
        db: &SqlitePool,
        changed_by: &ManageUserUser,
        smtp_pw: &str,
    ) -> Result<(), String> {
        let schnupperant = Role::find_by_name(db, "schnupperant").await.unwrap();
        let scheckbook = Role::find_by_name(db, "scheckbuch").await.unwrap();
        self.user.remove_role(db, changed_by, &schnupperant).await?;
        self.user.add_role(db, changed_by, &scheckbook).await?;

        if let Some(no_einschreibgebuehr) = Role::find_by_name(db, "no-einschreibgebuehr").await {
            self.add_role(db, changed_by, &no_einschreibgebuehr)
                .await
                .expect("role doesn't have a group");
        }

        let scheckbook = ScheckbuchUser::new(db, &self.user).await.unwrap();
        scheckbook.notify(db, smtp_pw).await?;

        Notification::create_for_steering_people(
            db,
            &format!(
                "Liebe Steuerberechtigte, {} hat unseren Schnupperkurs absolviert und nun ein Scheckbuch. Wie immer, freuen wir uns wenn du uns beim A+F Rudern unterstützt oder selber Ausfahrten ausschreibst. Bitte beachte, dass Scheckbuch-Personen nur Ausfahrten sehen, bei denen 'Scheckbuch-Anmeldungen erlauben' ausgewählt wurde.",
                self.name
            ),
            "Neues Scheckbuch",
            None,None
        )
        .await;

        ActivityBuilder::new(&format!(
            "{changed_by} hat dem ehemaligen Schnupperant {self} nun ein Scheckbuch gegeben"
        ))
        .relevant_for_user(&self)
        .save(db)
        .await;

        Ok(())
    }

    pub(crate) async fn move_to_schnupperinterest(
        self,
        db: &SqlitePool,
        changed_by: &ManageUserUser,
    ) -> Result<(), String> {
        let schnupperinterest = Role::find_by_name(db, "schnupper-interessierte")
            .await
            .unwrap();
        let schnupperant = Role::find_by_name(db, "schnupperant").await.unwrap();
        self.user.remove_role(db, changed_by, &schnupperant).await?;
        self.user
            .add_role(db, changed_by, &schnupperinterest)
            .await?;

        let schnupperinterest = SchnupperInterestUser::new(db, &self.user).await.unwrap();
        schnupperinterest.notify(db).await?;

        if let Some(role) = Role::find_by_name(db, "schnupper-betreuer").await {
            Notification::create_for_role(
                db,
                &role,
                &format!(
                    "Lieber Schnupperbetreuer, {} hat sich vom Schnupperkurs abgemeldet.",
                    self.name
                ),
                "Schnupperkurs Abmeldung",
                None,
                None,
            )
            .await;
        }

        ActivityBuilder::new(&format!(
            "{changed_by} hat dem eigentlichen Schnupperanten {self} wieder auf die 'Interessierten'-Liste zurückgegeben."
        ))
        .relevant_for_user(&self)
        .save(db)
        .await;

        Ok(())
    }

    pub(crate) async fn convert_to_unterstuetzend_user(
        self,
        db: &SqlitePool,
        smtp_pw: &str,
        changed_by: &ManageUserUser,
        member_since: &NaiveDate,
        birthdate: &NaiveDate,
        phone: NonEmptyString,
        address: NonEmptyString,
        membership_pdf: &TempFile<'_>,
    ) -> Result<(), String> {
        // Set data
        self.set_data_for_clubmember(
            db,
            changed_by,
            member_since,
            birthdate,
            phone,
            address,
            membership_pdf,
        )
        .await?;

        // Change roles
        let paid = Role::find_by_name(db, "paid").await.unwrap();
        if self.user.remove_role(db, changed_by, &paid).await.is_err() {
            self.remove_membership_pdf(db, changed_by).await;
            return Err("Kann noch kein normales Mitglied werden, da die Schnupperkurs-Gebühr noch nicht bezahlt wurde.".into());
        }
        let unterstuetzend = Role::find_by_name(db, "Unterstützend").await.unwrap();
        let scheckbook = Role::find_by_name(db, "schnupperant").await.unwrap();
        self.user.remove_role(db, changed_by, &scheckbook).await?;
        self.user.add_role(db, changed_by, &unterstuetzend).await?;
        if let Some(no_einschreibgebuehr) = Role::find_by_name(db, "no-einschreibgebuehr").await {
            self.add_role(db, changed_by, &no_einschreibgebuehr)
                .await
                .expect("role doesn't have a group");
        }

        let unterstuetzend = UnterstuetzendUser::new(db, &self.user).await.unwrap();
        unterstuetzend
            .send_welcome_mail_to_user(db, smtp_pw)
            .await?;
        if let Some(vorstand) = Role::find_by_name(db, "vorstand").await {
            Notification::create_for_role(
                db,
                &vorstand,
                &format!(
                    "Lieber Vorstand, {} nahm am Schnupperkurs teil und ist nun seit {} es ein neues unterstützendes Mitglied.",
                    self.name,
                    self.member_since_date.clone().unwrap()
                ),
                "Neues unterstützendes Vereinsmitglied",
                None,
                None,
            )
            .await;
        }

        ActivityBuilder::new(&format!(
            "{changed_by} hat den Schnupperant {self} auf ein unterstützendes Mitglied upgegraded!"
        ))
        .relevant_for_user(&self)
        .save(db)
        .await;

        Ok(())
    }

    pub(crate) async fn convert_to_foerdernd_user(
        self,
        db: &SqlitePool,
        smtp_pw: &str,
        changed_by: &ManageUserUser,
        member_since: &NaiveDate,
        birthdate: &NaiveDate,
        phone: NonEmptyString,
        address: NonEmptyString,
        membership_pdf: &TempFile<'_>,
    ) -> Result<(), String> {
        // Set data
        self.set_data_for_clubmember(
            db,
            changed_by,
            member_since,
            birthdate,
            phone,
            address,
            membership_pdf,
        )
        .await?;

        // Change roles
        let paid = Role::find_by_name(db, "paid").await.unwrap();
        if self.user.remove_role(db, changed_by, &paid).await.is_err() {
            self.remove_membership_pdf(db, changed_by).await;
            return Err("Kann noch kein normales Mitglied werden, da die Schnupperkurs-Gebühr noch nicht bezahlt wurde.".into());
        }
        let unterstuetzend = Role::find_by_name(db, "Förderndes Mitglied").await.unwrap();
        let scheckbook = Role::find_by_name(db, "schnupperant").await.unwrap();
        self.user.remove_role(db, changed_by, &scheckbook).await?;
        self.user.add_role(db, changed_by, &unterstuetzend).await?;
        if let Some(no_einschreibgebuehr) = Role::find_by_name(db, "no-einschreibgebuehr").await {
            self.add_role(db, changed_by, &no_einschreibgebuehr)
                .await
                .expect("role doesn't have a group");
        }

        let foerdernd = FoerderndUser::new(db, &self.user).await.unwrap();
        foerdernd.send_welcome_mail_to_user(db, smtp_pw).await?;
        if let Some(vorstand) = Role::find_by_name(db, "vorstand").await {
            Notification::create_for_role(
                db,
                &vorstand,
                &format!(
                    "Lieber Vorstand, {} nahm am Schnupperkurs teil und ist nun seit {} es ein neues förderndes Mitglied.",
                    self.name,
                    self.member_since_date.clone().unwrap()
                ),
                "Neues förderndes Vereinsmitglied",
                None,
                None,
            )
            .await;
        }

        ActivityBuilder::new(&format!(
            "{changed_by} hat den Schnupperant {self} auf ein förderndes Mitglied upgegraded!"
        ))
        .relevant_for_user(&self)
        .save(db)
        .await;

        Ok(())
    }

    // TODO: make private
    pub(crate) async fn notify(&self, db: &SqlitePool, smtp_pw: &str) -> Result<(), String> {
        self.notify_coxes_about_new_schnupperant(db).await;
        self.send_welcome_mail_to_user(db, smtp_pw).await?;

        ActivityBuilder::new(&format!(
            "{self} hat eine Mail bekommen (Inhalt: wir freuen uns auf ihn + senden detailliertere Infos später zu) und die Schnupperbetreuer wurden via Notification informiert."
        ))
        .relevant_for_user(self)
        .save(db)
        .await;

        Ok(())
    }

    async fn send_welcome_mail_to_user(
        &self,
        db: &SqlitePool,
        smtp_pw: &str,
    ) -> Result<(), String> {
        let Some(mail) = &self.mail else {
            return Err(format!(
                "Couldn't send mail, because user {self} has no mail"
            ));
        };
        Mail::send_single(
            db,
            mail,
            "ASKÖ Ruderverein Donau Linz | Anmeldung Schnupperkurs",
            format!(
                "Hallo {0},

es freut uns sehr, dich bei unserem Schnupperkurs willkommen heißen zu dürfen.

Bitte überweise die {1} € auf unser Bankkonto (IBAN: AT58 2032 0321 0072 9256) und gib beim Verwendungszweck 'Schnupperkurs {0}' an.

Detaillierte Informationen folgen noch, du wirst sie ein paar Tage vor dem Termin bekommen (wenn das Wetter/Wasserstand/... abschätzbar ist).

Riemen- & Dollenbruch,
ASKÖ Ruderverein Donau Linz",
                self.name,
                self.fee(db).await.unwrap().sum_in_cents/100
            ),
            smtp_pw,
        )
        .await?;

        Ok(())
    }

    async fn notify_coxes_about_new_schnupperant(&self, db: &SqlitePool) {
        if let Some(role) = Role::find_by_name(db, "schnupper-betreuer").await {
            Notification::create_for_role(
                db,
                &role,
                &format!(
                    "Lieber Schnupperbetreuer, {} hat sich zum Schnupperkurs angemeldet.",
                    self.name
                ),
                "Neuer Schnupperant",
                None,
                None,
            )
            .await;
        }
    }

    pub(crate) async fn create(
        db: &SqlitePool,
        created_by: &ManageUserUser,
        smtp_pw: &str,
        name: NonEmptyString,
        mail: &str,
    ) -> Result<(), String> {
        let role = Role::find_by_name(db, "schnupperant").await.unwrap();

        let name = name.as_str();
        sqlx::query!(
            "INSERT INTO user(name, mail)
            VALUES (?,?)",
            name,
            mail
        )
        .execute(db)
        .await
        .map_err(|e| e.to_string())?;

        let user = User::find_by_name(db, name).await.unwrap();
        user.add_role(db, created_by, &role).await?;

        let user = Self::new(db, &user).await.unwrap();
        user.notify(db, smtp_pw).await?;

        ActivityBuilder::new(&format!(
            "{created_by} hat {user} zur fixen Schnupperkurs-Anmeldung hinzugefügt."
        ))
        .relevant_for_user(&user)
        .save(db)
        .await;

        Ok(())
    }
}