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

use lettre::message::header::ContentType;
use lettre::message::{Attachment, MultiPart, SinglePart};
use lettre::transport::smtp::authentication::Credentials;
use lettre::{Message, SmtpTransport, Transport};
use std::fs;

pub struct SendEmailBuilder<'a> {
    pub from: &'a str,
    pub passwd: &'a str,
    pub smtp: &'a str, // smtp.gmail.com
    pub receiver: &'a str,
    pub _type: &'a str, // text or html
    pub title: &'a str,
    pub content: &'a str,
    pub file_path: Option<&'a str>,
}

fn get_content(_type: &str, content: &str) -> SinglePart {
    if _type == "text" {
        return SinglePart::plain(content.to_string());
    }

    SinglePart::builder()
        .header(ContentType::TEXT_HTML)
        .body(content.to_string())
}

fn file_to_attachment(path: &str) -> crate::core::error2::Result<SinglePart> {
    let data = fs::read(path)?;
    let filename = path.split('/').next_back().unwrap_or(path);

    let mime = mime_guess::from_path(path)
        .first_or_octet_stream()
        .essence_str()
        .to_string();

    let content_type = mime.parse().map_err(|e| anyhow::anyhow!("{}", e))?;

    Ok(Attachment::new(filename.to_string()).body(data, content_type))
}

pub async fn do_send_email(builder: &SendEmailBuilder<'_>) -> crate::core::error2::Result<()> {
    // 登录凭据
    let creds = Credentials::new(builder.from.to_string(), builder.passwd.to_string());

    // SMTP Server（示例为 Gmail）
    let mailer = SmtpTransport::relay(builder.smtp)
        .unwrap()
        .credentials(creds)
        .build();

    // 邮件
    let email = Message::builder()
        .from(builder.from.parse().unwrap())
        .to(builder.receiver.parse().unwrap())
        .subject(builder.title)
        .singlepart(get_content(builder._type, builder.content))
        .map_err(|e| anyhow::anyhow!("{}", e))?;

    // 发送
    match mailer.send(&email) {
        Ok(_) => {
            log::info!(
                "发送邮件成功: from={}, title={}, receiver={}",
                builder.from,
                builder.title,
                builder.receiver
            );

            Ok(())
        }
        Err(e) => {
            log::error!(
                "发送邮件失败: from={}, title={}, receiver={}, error_message={}, Error={:?}",
                builder.from,
                builder.title,
                builder.receiver,
                e,
                e
            );

            Err(crate::core::error2::Error::UnexpectedError(
                anyhow::anyhow!(e),
            ))
        }
    }
}

pub async fn send_email_attachment(
    builder: &SendEmailBuilder<'_>,
) -> crate::core::error2::Result<()> {
    // 登录凭据
    let creds = Credentials::new(builder.from.to_string(), builder.passwd.to_string());

    // SMTP Server（示例为 Gmail）
    let mailer = SmtpTransport::relay(builder.smtp)
        .unwrap()
        .credentials(creds)
        .build();

    let attachment = file_to_attachment(builder.file_path.unwrap())?;

    // 邮件
    let email = Message::builder()
        .from(builder.from.parse().unwrap())
        .to(builder.receiver.parse().unwrap())
        .subject(builder.title)
        .multipart(
            MultiPart::mixed()
                .singlepart(get_content(builder._type, builder.content))
                .singlepart(attachment),
        )
        .map_err(|e| anyhow::anyhow!("{}", e))?;

    // 发送
    match mailer.send(&email) {
        Ok(_) => Ok(()),
        Err(e) => {
            log::error!(
                "发送邮件失败: from={}, title={}, receiver={}, error_message={}, Error={:?}",
                builder.from,
                builder.title,
                builder.receiver,
                e,
                e
            );

            Err(crate::core::error2::Error::UnexpectedError(
                anyhow::anyhow!(e),
            ))
        }
    }
}