simple_smtp_sender 0.3.0

A Simple SMTP Email sender crate with the support of sync or async sending. Can be called from Python. Powered by PyO3.
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::EmailConfig;
use crate::email::{async_send_email, send_email};

#[derive(Clone, Debug)]
/// Builder pattern for sending emails
pub struct EmailClient {
    pub config: EmailConfig,
    pub recipient: Vec<String>,
    pub subject: String,
    pub body: Option<String>,
    pub cc: Option<Vec<String>>,
    pub bcc: Option<Vec<String>>,
    pub attachment: Option<String>,
}

impl Default for EmailClient {
    fn default() -> Self {
        EmailClient {
            config: EmailConfig::from_env(),
            recipient: vec![],
            subject: "No subject".to_string(),
            body: None,
            cc: None,
            bcc: None,
            attachment: None,
        }
    }
}

impl EmailClient {
    /// Creates a new EmailClient with the given configuration
    /// # Arguments
    /// * `config` - Email configuration
    pub fn new(config: impl Into<EmailConfig>) -> Self {
        EmailClient {
            config: config.into(),
            ..Self::default()
        }
    }

    /// Sets the email configuration
    /// # Arguments
    /// * `config` - Email configuration
    pub fn config(mut self, config: impl Into<EmailConfig>) -> Self {
        self.config = config.into();
        self
    }

    /// Sets the recipient(s) of the email
    /// # Arguments
    /// * `recipient` - A vector of recipient email addresses
    pub fn recipient(mut self, recipient: Vec<impl Into<String>>) -> Self {
        self.recipient = recipient.into_iter().map(|r| r.into()).collect();
        self
    }

    /// Sets the subject of the email
    /// # Arguments
    /// * `subject` - Subject of the email
    pub fn subject(mut self, subject: impl Into<String>) -> Self {
        self.subject = subject.into();
        self
    }

    /// Sets the body of the email
    /// # Arguments
    /// * `body` - Body content of the email
    pub fn body(mut self, body: impl Into<String>) -> Self {
        self.body = Some(body.into());
        self
    }

    /// Sets the CC recipients of the email
    /// # Arguments
    /// * `cc` - A vector of CC email addresses
    pub fn cc(mut self, cc: Vec<String>) -> Self {
        self.cc = Some(cc);
        self
    }

    /// Sets the BCC recipients of the email
    /// # Arguments
    /// * `bcc` - A vector of BCC email addresses
    pub fn bcc(mut self, bcc: Vec<String>) -> Self {
        self.bcc = Some(bcc);
        self
    }

    /// Sets the attachment of the email
    /// # Arguments
    /// * `attachment` - File path of the attachment
    pub fn attachment(mut self, attachment: impl Into<String>) -> Self {
        self.attachment = Some(attachment.into());
        self
    }

    /// Sends the email synchronously
    /// # Returns
    /// * `anyhow::Result<()>` - Result of the email sending operation
    pub fn send(self) -> anyhow::Result<()> {
        send_email(
            self.config,
            self.recipient,
            self.subject,
            self.body.unwrap_or_default(),
            self.cc,
            self.bcc,
            self.attachment,
        )
    }

    /// Sends the email asynchronously
    /// # Returns
    /// * `anyhow::Result<()>` - Result of the email sending operation
    pub async fn send_async(self) -> anyhow::Result<()> {
        async_send_email(
            self.config,
            self.recipient,
            self.subject,
            self.body.unwrap_or_default(),
            self.cc,
            self.bcc,
            self.attachment,
        )
        .await
    }
}