mailfred 0.1.2

Process emails as an HTTP server
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

use std::io;

use async_trait::async_trait;
use mail_builder::{mime::MimePart, MessageBuilder as EmailBuilder};
use mail_send::{self as smtp, SmtpClient, SmtpClientBuilder};
use tokio::net::TcpStream;
use tokio_rustls::client::TlsStream;

use crate::{
    message::{Kind, Message},
    transport::{Sender, Transport},
};

pub struct Smtp {
    pub domain: String,
    pub port: u16,
    pub user: String,
    pub password: String,
}

#[async_trait]
impl Transport for Smtp {
    const NAME: &'static str = "smtp";

    type Connection = SmtpConnection;
    type Error = smtp::Error;

    async fn connect(&self) -> smtp::Result<Self::Connection> {
        let client = SmtpClientBuilder::new(self.domain.as_ref(), self.port)
            // Building the client only fails while setting up TLS, and
            // `mail_send` reports it as a plain string with no error variant
            // of its own to map it to.
            .map_err(|err| smtp::Error::Io(io::Error::other(err)))?
            .implicit_tls(false)
            .credentials((self.user.as_ref(), self.password.as_ref()))
            .connect()
            .await?;

        Ok(SmtpConnection {
            client,
            origin: self.user.clone(),
        })
    }
}

pub struct SmtpConnection {
    client: SmtpClient<TlsStream<TcpStream>>,
    origin: String,
}

#[async_trait]
impl Sender for SmtpConnection {
    type Error = smtp::Error;

    async fn send(&mut self, msg: &Message) -> smtp::Result<()> {
        let parts = msg
            .body
            .iter()
            .cloned()
            .map(|part| match part.kind {
                Kind::Text => MimePart::new("text/plain", part.content),
                Kind::Html => MimePart::new("text/html", part.content),
                Kind::Attachment(name) => {
                    MimePart::new("application/octet-stream", part.content).attachment(name)
                }
            })
            .collect::<Vec<MimePart>>();

        let email = EmailBuilder::new()
            .from(self.origin.as_str())
            .to(msg.address.as_str())
            .subject(msg.header.as_str())
            .body(MimePart::new("multipart/mixed", parts));

        self.client.send(email).await
    }
}