smail 0.4.0

Cli tool to easily send emails with attachments
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


use colored::Colorize;
use lettre::{
    message::Mailbox, transport::smtp::authentication::Credentials, Message, SmtpTransport,
    Transport,
};
use std::fs;

use lettre::message::{header::ContentType, Attachment, MultiPart, SinglePart};
use crate::utils::parse_file_name;


use crate::{
    errors::{internal_error, mailer_send_error},
    security::decrypt_password,
    store::get_data,
};

use crate::utils::{handle_mailbox, handle_option};


/// Sends the email
pub async fn send_email(
    email_to: String,
    attachment: Option<String>,
    subject: Option<String>,
    body: Option<String>,
) {

    let from_email =get_data("email".to_string());
    let attachment = handle_option(attachment);
    let subject = handle_option(subject);
    let body = handle_option(body);

    let to_email_mbox = handle_mailbox(email_to.clone(), "Recipient email".to_string());
    let from_email_mbox = handle_mailbox(from_email.clone(), "Sender email".to_string());
        let mut email;


    if attachment.is_empty() {
        // No attachment, just body
        email = Message::builder()
            .from(from_email_mbox)
            .to(to_email_mbox)
            .subject(subject)
            .body(body)
            .unwrap_or_else(|_| {
                internal_error();
                std::process::exit(1)
            });
    } else if body.is_empty() {
        // No body, just attachment
        let attachment_part = file_builder(attachment);
        email = Message::builder()
            .from(from_email_mbox)
            .to(to_email_mbox)
            .subject(subject)
            .multipart(MultiPart::mixed().singlepart(attachment_part))
            .unwrap_or_else(|_| {
                internal_error();
                std::process::exit(1)
            });
    } else {
        // Both attachment and body
        let attachment_part = file_builder(attachment);
        email = Message::builder()
            .from(from_email_mbox)
            .to(to_email_mbox)
            .subject(subject)
            .multipart(
                MultiPart::mixed()
                    .singlepart(SinglePart::plain(body))
                    .singlepart(attachment_part)
            )
            .unwrap_or_else(|_| {
                internal_error();
                std::process::exit(1)
            });
    }


    let password = get_data("password".to_string());
    let provider = get_data("provider".to_string());

    let decrypted_password = decrypt_password(password);

    let creds = Credentials::new(from_email, decrypted_password);

    let mailer = SmtpTransport::relay(&provider)
        .unwrap_or_else(|_| {
            internal_error();
            std::process::exit(1)
        })
        .credentials(creds)
        .build();

    match mailer.send(&email) {
        Ok(_) => {
            println!("{}", "Email sent successfully!".green())
        }
        Err(e) => {
            let str_error = e.to_string();
            mailer_send_error(str_error)
        }
    }
}




/// Takes in the file path and returns a SinglePart struct
pub fn file_builder(filename: String) -> SinglePart {
    let file_body = match fs::read(filename.clone()) {
        Ok(file_body) => file_body,
        Err(e) => {
            if e.to_string().contains("Is a directory") {
                eprintln!("{}", "Email attachment can not be a directory".red())
            } else {
                eprintln!(
                    "{}",
                    "There was an issue with processing the attachment".red()
                )
            }

            std::process::exit(1);
        }
    };
    let content_type = match ContentType::parse("application/any") {
        Ok(content_type) => content_type,
        Err(_) => {
            eprintln!(
                "{}",
                "There was an issue with processing the attachment".red()
            );
            std::process::exit(1);
        }
    };

    Attachment::new(parse_file_name(filename)).body(file_body, content_type)
}