tuta_poll 0.1.0

tuta library to fetch new mails, decrypt them, and mark them as read
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

use anyhow::Result;
use futures_util::pin_mut;
use futures_util::StreamExt;
use tracing::{info, warn};
use tuta_poll::client::Client;
use tuta_poll::types::ReadStatus;
use tuta_poll::*;

#[tokio::main]
async fn main() -> Result<()> {
    tracing_subscriber::fmt::init();

    let mut email_address = String::new();
    println!("Please enter email: ");
    std::io::stdin()
        .read_line(&mut email_address)
        .expect("Expected email");
    email_address = email_address.trim().to_string();
    let password = rpassword::prompt_password("Password: ").expect("Expected password");

    let config = config::Account {
        email_address,
        password,
        watch_spam: false,
        show_name: true,
        show_subject: true,
        show_body: true,
    };

    let client = Client::new(&config).await?;
    let connector = client.get_websocket_connector()?;

    loop {
        info!("Connecting to websocket");
        let mut socket = connector.connect()?;

        while let Ok(has_new) = socket.has_new().await {
            if !has_new {
                continue;
            }
            let mails = client.get_mails();
            pin_mut!(mails);
            while let Some(mail) = mails.next().await {
                let mut mail = mail?;
                if mail.read_status == ReadStatus::Read {
                    continue;
                }
                let decrypted_mail = client.decrypt(&mail).await;
                info!("Got mail: {:?}", decrypted_mail);
                client.set_read_status(&mut mail, ReadStatus::Read).await?;
            }
        }
        warn!("Error getting mails. Retrying in 10s");
        std::thread::sleep(std::time::Duration::from_secs(10));
    }
    // socket.close(None);
    // Ok(())
}