mail-list 0.2.5-alpha

Email subscriptions list library. Unicast, narrowcast and broadcast lists
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

use std::borrow::Cow;

use lettre::{
    Address, AsyncSmtpTransport, AsyncTransport, Message, message::Mailbox,
    transport::smtp::response::Severity,
};

use crate::{EmailEnvelopeDetails, MailListError, MailListResult};

#[derive(Debug)]
pub struct Smtps {
    pub(crate) domain: Cow<'static, str>,
    pub(crate) from: Mailbox,
    pub(crate) reply_to: Option<Mailbox>,
    pub(crate) ehlo_name: Option<Cow<'static, str>>,
    #[cfg(feature = "tokio-runtime")]
    pub(crate) mailer: AsyncSmtpTransport<lettre::Tokio1Executor>,
}

impl Smtps {
    pub fn set_reply_to(
        &mut self,
        reply_to_name: &str,
        reply_to_address: &str,
    ) -> MailListResult<&mut Self> {
        self.reply_to.replace(Mailbox::new(
            Some(reply_to_name.to_string()),
            reply_to_address
                .parse::<Address>()
                .map_err(|error| MailListError::Mailer(error.to_string()))?,
        ));

        Ok(self)
    }

    pub fn domain(&self) -> &str {
        self.domain.as_ref()
    }

    pub fn ehlo_name(&self) -> Option<&Cow<'_, str>> {
        self.ehlo_name.as_ref()
    }

    pub fn from(&self) -> &Mailbox {
        &self.from
    }

    pub fn reply_to(&self) -> Option<&Mailbox> {
        self.reply_to.as_ref()
    }

    #[cfg(feature = "tokio-runtime")]
    pub fn mailer(&self) -> &AsyncSmtpTransport<lettre::Tokio1Executor> {
        &self.mailer
    }

    pub async fn send(&self, message: &EmailEnvelopeDetails) -> MailListResult<()> {
        let email = Message::builder().from(self.from().clone());

        let email = if let Some(reply_to) = self.reply_to() {
            email.reply_to(reply_to.clone())
        } else {
            email
        };

        let email = email
            .to(message
                .to
                .parse::<Mailbox>()
                .map_err(|error| MailListError::Mailer(error.to_string()))?)
            .subject(message.subject.as_str())
            .header(lettre::message::header::ContentType::TEXT_HTML)
            .body(message.body.to_string())
            .map_err(|error| MailListError::Mailer(error.to_string()))?;

        let response = self
            .mailer
            .send(email)
            .await
            .map_err(|error| MailListError::MailDelivery(error.to_string()))?;

        if response.code().severity == Severity::PositiveCompletion {
            Ok(())
        } else {
            Err(MailListError::Smtps(
                response.message().map(|msg| msg.to_string()).collect(),
            ))
        }
    }

    pub async fn test_connection(&self) -> MailListResult<bool> {
        self.mailer
            .test_connection()
            .await
            .map_err(|error| MailListError::Mailer(error.to_string()))
    }
}