grr-cli 0.4.0

Google tools from the terminal, at maximum performance: zero-config Gmail, Calendar, Drive, Contacts, Chat and Forms over HTTP/3
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

//! Draft operations

use base64::Engine;

use crate::core::error::Result;
use crate::gmail::models::*;

use super::build_email;

impl super::GmailClient {
    // ═══════════════════════════════════════════════════════════════════
    // Draft Operations
    // ══════════════════════════════════════════════════════════════════

    /// Create draft
    pub async fn create_draft(&self, to: &str, subject: &str, body: &str) -> Result<Draft> {
        let request = draft_request(to, subject, body)?;

        let response = self
            .core
            .execute(
                self.core
                    .post(self.api_url("users/me/drafts")?)
                    .json(&request),
            )
            .await?;

        Ok(response.json().await?)
    }

    /// List drafts
    pub async fn list_drafts(&self, max_results: usize) -> Result<Vec<Draft>> {
        let response = self
            .core
            .execute(
                self.core
                    .get(self.api_url("users/me/drafts")?)
                    .query(&[("maxResults", &max_results.to_string())]),
            )
            .await?;

        let list_response: DraftList = response.json().await?;
        Ok(list_response.drafts)
    }

    /// Get draft
    pub async fn get_draft(&self, draft_id: &str) -> Result<Draft> {
        let response = self
            .core
            .execute(
                self.core
                    .get(self.api_url(&format!("users/me/drafts/{}", draft_id))?),
            )
            .await?;
        Ok(response.json().await?)
    }

    /// Send draft
    pub async fn send_draft(&self, draft_id: &str) -> Result<Message> {
        let response = self
            .core
            .execute(
                self.core
                    .post(self.api_url(&format!("users/me/drafts/{}/send", draft_id))?),
            )
            .await?;
        Ok(response.json().await?)
    }

    /// Update draft
    pub async fn update_draft(
        &self,
        draft_id: &str,
        to: &str,
        subject: &str,
        body: &str,
    ) -> Result<Draft> {
        let request = draft_request(to, subject, body)?;

        let response = self
            .core
            .execute(
                self.core
                    .put(self.api_url(&format!("users/me/drafts/{}", draft_id))?)
                    .json(&request),
            )
            .await?;

        Ok(response.json().await?)
    }

    /// Delete draft
    pub async fn delete_draft(&self, draft_id: &str) -> Result<()> {
        self.core
            .execute(
                self.core
                    .delete(self.api_url(&format!("users/me/drafts/{}", draft_id))?),
            )
            .await?;
        Ok(())
    }
}

/// Build the JSON body shared by draft create and update from a plain
/// (to, subject, body) triple.
fn draft_request(to: &str, subject: &str, body: &str) -> Result<CreateDraftRequest> {
    let email = build_email(to, subject, body, None, None)?;
    let raw = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(email.as_bytes());
    Ok(CreateDraftRequest {
        message: DraftMessage {
            raw,
            thread_id: None,
        },
    })
}