zero4rs 2.0.0

zero4rs is a powerful, pragmatic, and extremely fast web framework for Rust
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::prelude2::*;

use crate::core::http_clients::EmailClient;
use crate::core::remail::{do_send_email, SendEmailBuilder};
use crate::services::newsletter_service::SubscribeFormData;
use crate::services::newsletter_service::SubscriberEmail;

use crate::services::newsletter_service::insert_subscriber;
use crate::services::newsletter_service::store_token;

#[derive(serde::Deserialize)]
pub struct SendEmailParams {
    pub subject: String,
    pub receiver: String,
    pub email_body: String,
}

pub async fn send_confirmation_email(
    _receiver: SubscriberEmail,
    _email_client: &EmailClient,
    _confirmation_link: &str,
) -> Result<()> {
    let html_body = format!(
        "Welcome to our newsletter!<br />\
        Click <a href=\"{}\">here</a> to confirm your subscription.",
        _confirmation_link
    );

    _email_client
        .send_email(&_receiver, "Welcome!", &html_body)
        .await?;

    Ok(())
}

// curl --request POST --data 'name=le%20guin&email=ursula_le_guin%40gmail.com' 127.0.0.1:8000/subscriptions --verbose
pub async fn subscribe(
    _form: web::Form<SubscribeFormData>,
    app_state: web::Data<AppContext>,
) -> Result<HttpResponse> {
    let subscription_token = crate::commons::random_token();

    let confirmation_link = format!(
        "https://my-api.com/subscriptions/confirm?subscription_token={}",
        subscription_token
    );

    // validate
    let new_subscriber = _form
        .0
        .try_into()
        .map_err(|e| Error::invalid_request(format!("参数有误: error={:}", e)))?;

    let mut transaction = app_state
        .mysql()
        .begin()
        .await
        .context("Failed to acquire a Postgres connection from the pool")
        .map_err(Error::UnexpectedError)?;

    // insert into email
    let subscriber_id = insert_subscriber(&mut transaction, &new_subscriber)
        .await
        .context("Failed to insert new subscriber in the database.")
        .map_err(Error::UnexpectedError)?;

    // save token
    store_token(&mut transaction, subscriber_id, &subscription_token)
        .await
        .context("Failed to store the confirmation token for a new subscriber.")
        .map_err(Error::UnexpectedError)?;

    // if commit or rollback have not been called before the Transaction object goes out of scope (i.e. Drop is invoked),
    // a rollback command is queued to be executed as soon as an opportunity arises.
    transaction
        .commit()
        .await
        .context("Failed to commit SQL transaction to store a new subscriber.")
        .map_err(Error::UnexpectedError)?;

    // send confirm email
    send_confirmation_email(
        new_subscriber.email,
        &app_state.email_client,
        &confirmation_link,
    )
    .await
    .context("Failed to send a confirmation email.")
    .map_err(Error::UnexpectedError)?;

    Ok(HttpResponse::Ok().body(confirmation_link.to_string()))
}

pub async fn send_email(
    _form: web::Form<SendEmailParams>,
    _app_state: web::Data<crate::server::AppContext>,
) -> impl Responder {
    let receiver = match SubscriberEmail::parse(_form.0.receiver) {
        Ok(email) => email,
        Err(e) => {
            return format!("Validation failed: {:?}", e);
        }
    };

    match _app_state
        .email_client
        .send_email(
            &receiver,
            _form.0.subject.as_ref(),
            _form.0.email_body.as_ref(),
        )
        .await
    {
        Ok(()) => {
            log::info!("New email send successful");
            "Ok".to_string()
        }
        Err(e) => {
            format!("Failed to SendEmail: {:?}", e)
        }
    }
}

pub async fn send_emails() -> impl Responder {
    match do_send_email(&SendEmailBuilder {
        from: "asdasdf@126.com",
        passwd: "asdfasdf",
        smtp: "smtp.gmail.com",
        receiver: "asdfsadf@qq.com",
        _type: "text",
        title: "激活账号",
        content: "激活账号sad",
        file_path: None,
    })
    .await
    {
        Ok(_) => {}
        Err(e) => {
            log::error!("Failed to send email: {:?}", e);
        }
    }

    "Ok".to_string()
}