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
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
142
143
144
145
146
147
148

//! Label operations

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

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

    /// List labels
    pub async fn list_labels(&self) -> Result<Vec<Label>> {
        let response = self
            .core
            .execute(self.core.get(self.api_url("users/me/labels")?))
            .await?;
        let list_response: LabelList = response.json().await?;
        Ok(list_response.labels)
    }

    /// Get label
    pub async fn get_label(&self, label_id: &str) -> Result<Label> {
        let response = self
            .core
            .execute(
                self.core
                    .get(self.api_url(&format!("users/me/labels/{}", label_id))?),
            )
            .await?;
        Ok(response.json().await?)
    }

    /// Create label with options
    pub async fn create_label(&self, name: &str, options: CreateLabelOptions) -> Result<Label> {
        let request = CreateLabelRequest {
            name: name.to_string(),
            label_list_visibility: options.label_list_visibility,
            message_list_visibility: options.message_list_visibility,
            color: options.color,
        };

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

    /// Update label
    pub async fn update_label(&self, label_id: &str, options: UpdateLabelOptions) -> Result<Label> {
        let request = UpdateLabelRequest {
            name: options.name,
            label_list_visibility: options.label_list_visibility,
            message_list_visibility: options.message_list_visibility,
            color: options.color,
        };

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

    pub async fn patch_label(&self, label_id: &str, options: UpdateLabelOptions) -> Result<Label> {
        let request = UpdateLabelRequest {
            name: options.name,
            label_list_visibility: options.label_list_visibility,
            message_list_visibility: options.message_list_visibility,
            color: options.color,
        };

        let response = self
            .core
            .execute(
                self.core
                    .patch(self.api_url(&format!("users/me/labels/{label_id}"))?)
                    .json(&request),
            )
            .await?;
        Ok(response.json().await?)
    }

    /// Modify labels on message
    pub async fn modify_labels(
        &self,
        message_id: &str,
        add_labels: &[String],
        remove_labels: &[String],
    ) -> Result<Message> {
        let request = ModifyLabelsRequest {
            add_label_ids: add_labels.to_vec(),
            remove_label_ids: remove_labels.to_vec(),
        };

        let response = self
            .core
            .execute(
                self.core
                    .post(self.api_url(&format!("users/me/messages/{}/modify", message_id))?)
                    .json(&request),
            )
            .await?;
        Ok(response.json().await?)
    }

    /// Batch modify labels
    pub async fn batch_modify_labels(
        &self,
        message_ids: &[String],
        add_labels: &[String],
        remove_labels: &[String],
    ) -> Result<()> {
        let request = BatchModifyLabelsRequest {
            ids: message_ids.to_vec(),
            add_label_ids: add_labels.to_vec(),
            remove_label_ids: remove_labels.to_vec(),
        };

        self.core
            .execute(
                self.core
                    .post(self.api_url("users/me/messages/batchModify")?)
                    .json(&request),
            )
            .await?;
        Ok(())
    }

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