lemmy_email 1.0.0-alpha.4

A link aggregator for the fediverse
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::{send_email, user_email, user_language};
use lemmy_db_schema::{
  source::{
    email_verification::{EmailVerification, EmailVerificationForm},
    local_site::LocalSite,
    password_reset_request::PasswordResetRequest,
  },
  utils::DbPool,
  RegistrationMode,
};
use lemmy_db_views::structs::LocalUserView;
use lemmy_utils::{error::LemmyResult, settings::structs::Settings};

pub async fn send_password_reset_email(
  user: &LocalUserView,
  pool: &mut DbPool<'_>,
  settings: &Settings,
) -> LemmyResult<()> {
  // Generate a random token
  let token = uuid::Uuid::new_v4().to_string();

  let lang = user_language(user);
  let subject = &lang.password_reset_subject(&user.person.name);
  let protocol_and_hostname = settings.get_protocol_and_hostname();
  let reset_link = format!("{}/password_change/{}", protocol_and_hostname, &token);
  let email = user_email(user)?;
  let body = &lang.password_reset_body(reset_link, &user.person.name);
  send_email(subject, &email, &user.person.name, body, settings).await?;

  // Insert the row after successful send, to avoid using daily reset limit while
  // email sending is broken.
  let local_user_id = user.local_user.id;
  PasswordResetRequest::create(pool, local_user_id, token.clone()).await?;
  Ok(())
}

/// Send a verification email
pub async fn send_verification_email(
  local_site: &LocalSite,
  user: &LocalUserView,
  new_email: &str,
  pool: &mut DbPool<'_>,
  settings: &Settings,
) -> LemmyResult<()> {
  let form = EmailVerificationForm {
    local_user_id: user.local_user.id,
    email: new_email.to_string(),
    verification_token: uuid::Uuid::new_v4().to_string(),
  };
  let verify_link = format!(
    "{}/verify_email/{}",
    settings.get_protocol_and_hostname(),
    &form.verification_token
  );
  EmailVerification::create(pool, &form).await?;

  let lang = user_language(user);
  let subject = lang.verify_email_subject(&settings.hostname);

  // If an application is required, use a translation that includes that warning.
  let body = if local_site.registration_mode == RegistrationMode::RequireApplication {
    lang.verify_email_body_with_application(&settings.hostname, &user.person.name, verify_link)
  } else {
    lang.verify_email_body(&settings.hostname, &user.person.name, verify_link)
  };

  send_email(&subject, new_email, &user.person.name, &body, settings).await
}

/// Returns true if email was sent.
pub async fn send_verification_email_if_required(
  local_site: &LocalSite,
  user: &LocalUserView,
  pool: &mut DbPool<'_>,
  settings: &Settings,
) -> LemmyResult<bool> {
  if !user.local_user.admin
    && local_site.require_email_verification
    && !user.local_user.email_verified
  {
    let email = user_email(user)?;
    send_verification_email(local_site, user, &email, pool, settings).await?;
    Ok(true)
  } else {
    Ok(false)
  }
}

pub async fn send_application_approved_email(
  user: &LocalUserView,
  settings: &Settings,
) -> LemmyResult<()> {
  let lang = user_language(user);
  let subject = lang.registration_approved_subject(&user.person.name);
  let email = user_email(user)?;
  let body = lang.registration_approved_body(&settings.hostname);
  send_email(&subject, &email, &user.person.name, &body, settings).await?;
  Ok(())
}

pub async fn send_application_denied_email(
  user: &LocalUserView,
  deny_reason: Option<String>,
  settings: &Settings,
) -> LemmyResult<()> {
  let lang = user_language(user);
  let subject = lang.registration_denied_subject(&user.person.name);
  let email = user_email(user)?;
  let body = lang.new_registration_denied_body(
    &settings.hostname,
    deny_reason.unwrap_or("unknown".to_string()),
  );
  send_email(&subject, &email, &user.person.name, &body, settings).await?;
  Ok(())
}

pub async fn send_email_verified_email(
  user: &LocalUserView,
  settings: &Settings,
) -> LemmyResult<()> {
  let lang = user_language(user);
  let subject = lang.email_verified_subject(&user.person.name);
  let email = user_email(user)?;
  let body = lang.email_verified_body();
  send_email(&subject, &email, &user.person.name, body, settings).await?;
  Ok(())
}