headless_lms_models/

email_templates.rs

use crate::prelude::*;
use utoipa::ToSchema;

#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Hash, Clone, Copy, sqlx::Type, ToSchema)]
#[sqlx(type_name = "email_template_type", rename_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum EmailTemplateType {
    ResetPasswordEmail,
    DeleteUserEmail,
    ConfirmEmailCode,
    Generic,
    CreditRegistrationAccountLinking,
    VerifyEmailAddress,
    CreditRegistrationActionNeeded,
    CreditRegistrationRegistered,
}

impl EmailTemplateType {
    /// Whether substitutions come from `email_deliveries.placeholders` instead of the recipient's
    /// account, which may not exist.
    pub fn uses_placeholder_bag(self) -> bool {
        matches!(
            self,
            Self::CreditRegistrationAccountLinking
                | Self::CreditRegistrationActionNeeded
                | Self::CreditRegistrationRegistered
        )
    }
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)]

pub struct EmailTemplate {
    pub id: Uuid,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub deleted_at: Option<DateTime<Utc>>,
    pub content: Option<serde_json::Value>,
    #[serde(rename = "template_type")]
    #[schema(rename = "template_type")]
    pub email_template_type: EmailTemplateType,
    pub subject: Option<String>,
    pub exercise_completions_threshold: Option<i32>,
    pub points_threshold: Option<i32>,
    pub course_id: Option<Uuid>,
    pub language: Option<String>,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)]

pub struct EmailTemplateNew {
    pub template_type: EmailTemplateType,
    pub language: Option<String>,
    pub content: Option<serde_json::Value>,
    pub subject: Option<String>,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)]

pub struct EmailTemplateUpdate {
    pub template_type: EmailTemplateType,
    pub subject: String,
    pub content: serde_json::Value,
    pub exercise_completions_threshold: Option<i32>,
    pub points_threshold: Option<i32>,
}

pub async fn get_email_templates(
    conn: &mut PgConnection,
    course_id: Uuid,
) -> ModelResult<Vec<EmailTemplate>> {
    let res = sqlx::query_as!(
        EmailTemplate,
        r#"
SELECT *
FROM email_templates
WHERE course_id = $1
  AND deleted_at IS NULL
        "#,
        course_id
    )
    .fetch_all(conn)
    .await?;
    Ok(res)
}

pub async fn get_all_email_templates(conn: &mut PgConnection) -> ModelResult<Vec<EmailTemplate>> {
    let res = sqlx::query_as!(
        EmailTemplate,
        r#"
SELECT *
FROM email_templates
WHERE deleted_at IS NULL
        "#,
    )
    .fetch_all(conn)
    .await?;
    Ok(res)
}

pub async fn get_generic_email_template_by_type_and_language(
    conn: &mut PgConnection,
    template_type: EmailTemplateType,
    language: &str,
) -> ModelResult<EmailTemplate> {
    let res = sqlx::query_as!(
        EmailTemplate,
        r#"
SELECT *
FROM email_templates
WHERE email_template_type = $1
  AND course_id IS NULL
  AND deleted_at IS NULL
  AND (
    language = $2
    OR language = 'en'
    OR language IS NULL
  )
ORDER BY CASE
    WHEN language = $2 THEN 0
    WHEN language = 'en' THEN 1
    WHEN language IS NULL THEN 2
    ELSE 3
  END
LIMIT 1
        "#,
        template_type as EmailTemplateType,
        language
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

/// Whether a generic template of this type would actually be found: checks only the `"en"` and
/// `NULL` language rows, the two the lookup above always falls back to regardless of the caller's
/// UI language.
pub async fn generic_email_template_exists(
    conn: &mut PgConnection,
    template_type: EmailTemplateType,
) -> ModelResult<bool> {
    let res = sqlx::query_scalar!(
        r#"
SELECT EXISTS(
  SELECT 1
  FROM email_templates
  WHERE email_template_type = $1
    AND course_id IS NULL
    AND deleted_at IS NULL
    AND (language = 'en' OR language IS NULL)
) AS "exists!"
        "#,
        template_type as EmailTemplateType,
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

pub async fn insert_email_template(
    conn: &mut PgConnection,
    course_id: Option<Uuid>,
    email_template: EmailTemplateNew,
    subject: Option<&'_ str>,
) -> ModelResult<EmailTemplate> {
    let subject_to_use = email_template.subject.as_deref().or(subject);
    let res = sqlx::query_as!(
        EmailTemplate,
        r#"
INSERT INTO email_templates (
    email_template_type,
    course_id,
    subject,
    language,
    content
  )
VALUES ($1, $2, $3, $4, $5) ON CONFLICT (email_template_type, language, deleted_at)
WHERE course_id IS NULL
  AND deleted_at IS NULL DO
UPDATE
SET subject = COALESCE(EXCLUDED.subject, email_templates.subject),
  content = COALESCE(EXCLUDED.content, email_templates.content),
  updated_at = NOW()
RETURNING *
        "#,
        email_template.template_type as EmailTemplateType,
        course_id,
        subject_to_use,
        email_template.language,
        email_template.content,
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

/// Inserts a global template, or returns `None` if a live one of the same type and language exists.
/// Unlike [`insert_email_template`], never overwrites the existing row.
pub async fn insert_global_email_template_if_absent(
    conn: &mut PgConnection,
    email_template: EmailTemplateNew,
) -> ModelResult<Option<EmailTemplate>> {
    let res = sqlx::query_as!(
        EmailTemplate,
        r#"
INSERT INTO email_templates (
    email_template_type,
    subject,
    language,
    content
  )
VALUES ($1, $2, $3, $4) ON CONFLICT (email_template_type, language, deleted_at)
WHERE course_id IS NULL
  AND deleted_at IS NULL DO NOTHING
RETURNING *
        "#,
        email_template.template_type as EmailTemplateType,
        email_template.subject,
        email_template.language,
        email_template.content,
    )
    .fetch_optional(conn)
    .await?;
    Ok(res)
}

pub async fn get_email_template(
    conn: &mut PgConnection,
    email_template_id: Uuid,
) -> ModelResult<EmailTemplate> {
    let res = sqlx::query_as!(
        EmailTemplate,
        r#"
SELECT *
FROM email_templates
WHERE id = $1
  AND deleted_at IS NULL
        "#,
        email_template_id
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

pub async fn update_email_template(
    conn: &mut PgConnection,
    email_template_id: Uuid,
    email_template_update: EmailTemplateUpdate,
) -> ModelResult<EmailTemplate> {
    let res = sqlx::query_as!(
        EmailTemplate,
        r#"
UPDATE email_templates
SET email_template_type = $1,
  subject = $2,
  content = $3,
  exercise_completions_threshold = $4,
  points_threshold = $5
WHERE id = $6
  AND deleted_at IS NULL
RETURNING *
  "#,
        email_template_update.template_type as EmailTemplateType,
        email_template_update.subject,
        email_template_update.content,
        email_template_update.exercise_completions_threshold,
        email_template_update.points_threshold,
        email_template_id
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

pub async fn delete_email_template(
    conn: &mut PgConnection,
    email_template_id: Uuid,
) -> ModelResult<EmailTemplate> {
    let deleted = sqlx::query_as!(
        EmailTemplate,
        r#"
UPDATE email_templates
SET deleted_at = NOW()
WHERE id = $1
  AND deleted_at IS NULL
RETURNING *
  "#,
        email_template_id
    )
    .fetch_one(conn)
    .await?;
    Ok(deleted)
}