rowt/src/model/user/scheckbuch.rs

use super::foerdernd::FoerderndUser;
use super::regular::RegularUser;
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, SCHECKBUCH,
};
use chrono::NaiveDate;
use rocket::async_trait;
use rocket::fs::TempFile;
use sqlx::SqlitePool;

special_user!(ScheckbuchUser, +"scheckbuch");

impl ScheckbuchUser {
    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 regular = Role::find_by_name(db, "Donau Linz").await.unwrap();
        let scheckbook = Role::find_by_name(db, "scheckbuch").await.unwrap();
        self.user.remove_role(db, changed_by, &scheckbook).await?;
        self.user.add_role(db, changed_by, &regular).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, {} hatte ein Scheckbuch und ist nun seit {} ein neues reguläres Mitglied. 🎉",
                self.name,
                member_since
            ),
            "Neues Vereinsmitglied",
            None,
            None,
        )
        .await;

        ActivityBuilder::new(&format!(
            "{changed_by} hat den Scheckbuch-User {self} auf ein reguläres Mitglied upgegraded! Die Steuerpersonen wurden via Notification informiert."
        ))
        .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 unterstuetzend = Role::find_by_name(db, "Unterstützend").await.unwrap();
        let scheckbook = Role::find_by_name(db, "scheckbuch").await.unwrap();
        self.user.remove_role(db, changed_by, &scheckbook).await?;
        self.user.add_role(db, changed_by, &unterstuetzend).await?;

        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, {} hatte ein Scheckbuch und ist nun seit {} ein neues unterstützendes Mitglied.",
                    self.name,
                    member_since
                ),
                "Neues unterstützendes Vereinsmitglied",
                None,
                None,
            )
            .await;
        }
        ActivityBuilder::new(&format!("{changed_by} hat den Scheckbuch-User {self} auf ein unterstützendes Mitglied upgegraded!"))
                .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 unterstuetzend = Role::find_by_name(db, "Förderndes Mitglied").await.unwrap();
        let scheckbook = Role::find_by_name(db, "scheckbuch").await.unwrap();
        self.user.remove_role(db, changed_by, &scheckbook).await?;
        self.user.add_role(db, changed_by, &unterstuetzend).await?;

        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, {} hatte ein Scheckbuch und ist nun seit {} ein neues förderndes Mitglied.",
                    self.name,
                    member_since
                ),
                "Neues förderndes Vereinsmitglied",
                None,
                None,
            )
            .await;
        }
        ActivityBuilder::new(&format!(
            "{changed_by} hat den Scheckbuch-User {self} auf ein förderndes Mitglied upgegraded!"
        ))
        .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_scheckbuch(db).await;
        self.send_welcome_mail_to_user(db, smtp_pw).await?;

        ActivityBuilder::new(&format!(
            "{self} hat eine Info-Mail bekommen (Erklärung Scheckbuch, Ruderapp) und alle Steuerberechtigten wurden informiert."
        ))
        .user(self)
        .save(db)
        .await;

        Ok(())
    }

    pub(crate) async fn send_welcome_mail_to_user(
        &self,
        db: &SqlitePool,
        smtp_pw: &str,
    ) -> Result<(), String> {
        let Some(mail) = &self.mail else {
            return Err(
                "Kann Mail nicht versenden, weil der User keine Mailadresse hinterlegt hat.".into(),
            );
        };
        Mail::send_single(
            db,
            mail,
            "ASKÖ Ruderverein Donau Linz | Dein Scheckbuch wartet auf Dich",
            format!(
"Hallo {0},

herzlich willkommen beim ASKÖ Ruderverein Donau Linz! Wir freuen uns sehr, dass Du Dich entschieden hast, das Rudern bei uns auszuprobieren. Mit Deinem Scheckbuch kannst Du jetzt an fünf Ausfahrten teilnehmen und so diesen Sport in seiner vollen Vielfalt erleben. Falls du die {1} € noch nicht bezahlt hast, nimm diese bitte zur nächsten Ausfahrt mit (oder überweise sie auf unser Bankkonto [dieses findest du auf https://rudernlinz.at]).

Für die Organisation unserer Ausfahrten nutzen wir app.rudernlinz.at. Logge Dich bitte mit Deinem Namen ('{0}', ohne Anführungszeichen) ein. Beim ersten Mal kannst Du das Passwortfeld leer lassen. Unter 'Geplante Ausfahrten' kannst Du Dich jederzeit für eine Ausfahrt anmelden. Wir bieten mindestens einmal pro Woche Ausfahrten an, sowohl für Anfänger als auch für Fortgeschrittene (A+F Rudern). Zusätzliche Ausfahrten werden von unseren Steuerleuten ausgeschrieben, öfters reinschauen kann sich also lohnen :-)

Nach deinen 5 Ausfahrten würden wir uns freuen, dich als Mitglied in unserem Verein begrüßen zu dürfen.

Wir freuen uns darauf, Dich bald am Wasser zu sehen und gemeinsam tolle Erfahrungen zu sammeln!

Riemen- & Dollenbruch,
ASKÖ Ruderverein Donau Linz", self.name, SCHECKBUCH/100),
            smtp_pw,
        ).await?;

        Ok(())
    }

    async fn notify_coxes_about_new_scheckbuch(&self, db: &SqlitePool) {
        Notification::create_for_steering_people(
            db,
            &format!(
                "Liebe Steuerberechtigte, {} hat 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;
    }

    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, "scheckbuch").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 Scheckbuch {user} angelegt."))
            .user(&user)
            .save(db)
            .await;

        Ok(())
    }
}