Skip to main content

oriko_services/
gmail.rs

1use async_trait::async_trait;
2use serde::{Deserialize, Serialize};
3
4const GMAIL_API_BASE: &str = "https://gmail.googleapis.com/gmail/v1";
5
6#[derive(Debug, Serialize, Deserialize)]
7pub struct GmailMessage {
8    pub id: String,
9    #[serde(rename = "threadId")]
10    pub thread_id: String,
11}
12
13#[derive(Debug, Serialize, Deserialize)]
14pub struct GmailMessageListResponse {
15    pub messages: Option<Vec<GmailMessage>>,
16    pub next_page_token: Option<String>,
17    pub result_size_estimate: Option<u32>,
18}
19
20#[derive(Debug, Serialize, Deserialize)]
21pub struct GmailMessageHeader {
22    pub name: String,
23    pub value: String,
24}
25
26#[derive(Debug, Serialize, Deserialize)]
27pub struct GmailMessagePart {
28    #[serde(rename = "mimeType")]
29    pub mime_type: Option<String>,
30    pub filename: Option<String>,
31    pub headers: Option<Vec<GmailMessageHeader>>,
32    pub body: Option<GmailMessageBody>,
33    pub parts: Option<Vec<GmailMessagePart>>,
34}
35
36#[derive(Debug, Serialize, Deserialize)]
37pub struct GmailMessageBody {
38    pub data: Option<String>,
39    pub size: Option<u32>,
40}
41
42#[derive(Debug, Serialize, Deserialize)]
43pub struct GmailFullMessage {
44    pub id: String,
45    #[serde(rename = "threadId")]
46    pub thread_id: String,
47    pub label_ids: Option<Vec<String>>,
48    pub snippet: Option<String>,
49    pub payload: Option<GmailMessagePart>,
50    pub internal_date: Option<String>,
51}
52
53#[derive(Debug, Clone)]
54pub struct ParsedEmail {
55    pub provider_id: String,
56    pub subject: Option<String>,
57    pub from_email: Option<String>,
58    pub from_name: Option<String>,
59    pub received_at: Option<String>,
60    pub body_html: Option<String>,
61    pub body_text: Option<String>,
62    pub snippet: Option<String>,
63}
64
65#[async_trait]
66pub trait TokenProvider: Send + Sync {
67    async fn get_access_token(&self) -> Result<String, String>;
68}
69
70pub struct GmailClient {
71    http_client: reqwest::Client,
72    token_provider: Box<dyn TokenProvider>,
73}
74
75impl GmailClient {
76    pub fn builder() -> GmailClientBuilder {
77        GmailClientBuilder::new()
78    }
79
80    pub async fn fetch_messages(
81        &self,
82        max_results: Option<u32>,
83    ) -> Result<Vec<GmailMessage>, String> {
84        let access_token = self.token_provider.get_access_token().await?;
85
86        let max = max_results.unwrap_or(10);
87        let url = format!("{}/users/me/messages?maxResults={}", GMAIL_API_BASE, max);
88
89        let response = self
90            .http_client
91            .get(&url)
92            .bearer_auth(&access_token)
93            .send()
94            .await
95            .map_err(|e| format!("Failed to fetch messages: {}", e))?;
96
97        let status = response.status();
98        let response_text = response
99            .text()
100            .await
101            .map_err(|e| format!("Failed to read response: {}", e))?;
102
103        if !status.is_success() {
104            return Err(format!("Gmail API error ({}): {}", status, response_text));
105        }
106
107        let list_response: GmailMessageListResponse = serde_json::from_str(&response_text)
108            .map_err(|e| format!("Failed to parse message list: {}", e))?;
109
110        Ok(list_response.messages.unwrap_or_default())
111    }
112
113    pub async fn fetch_message(&self, message_id: &str) -> Result<GmailFullMessage, String> {
114        let access_token = self.token_provider.get_access_token().await?;
115
116        let url = format!("{}/users/me/messages/{}", GMAIL_API_BASE, message_id);
117
118        let response = self
119            .http_client
120            .get(&url)
121            .bearer_auth(&access_token)
122            .send()
123            .await
124            .map_err(|e| format!("Failed to fetch message: {}", e))?;
125
126        let status = response.status();
127        let response_text = response
128            .text()
129            .await
130            .map_err(|e| format!("Failed to read response: {}", e))?;
131
132        if !status.is_success() {
133            return Err(format!("Gmail API error ({}): {}", status, response_text));
134        }
135
136        serde_json::from_str(&response_text).map_err(|e| format!("Failed to parse message: {}", e))
137    }
138
139    pub fn parse_email(&self, message: &GmailFullMessage) -> Result<ParsedEmail, String> {
140        let mut parsed = ParsedEmail {
141            provider_id: message.id.clone(),
142            subject: None,
143            from_email: None,
144            from_name: None,
145            received_at: message.internal_date.clone(),
146            body_html: None,
147            body_text: None,
148            snippet: message.snippet.clone(),
149        };
150
151        if let Some(ref payload) = message.payload {
152            // Extract headers
153            if let Some(ref headers) = payload.headers {
154                for header in headers {
155                    match header.name.as_str() {
156                        "Subject" => parsed.subject = Some(header.value.clone()),
157                        "From" => {
158                            let from = parse_from_header(&header.value);
159                            parsed.from_email = from.0;
160                            parsed.from_name = from.1;
161                        }
162                        "Date" => {
163                            if parsed.received_at.is_none() {
164                                parsed.received_at = Some(header.value.clone());
165                            }
166                        }
167                        _ => {}
168                    }
169                }
170            }
171
172            // Extract body
173            extract_body(payload, &mut parsed);
174        }
175
176        Ok(parsed)
177    }
178}
179
180pub struct GmailClientBuilder {
181    http_client: Option<reqwest::Client>,
182    token_provider: Option<Box<dyn TokenProvider>>,
183}
184
185impl GmailClientBuilder {
186    pub fn new() -> Self {
187        Self {
188            http_client: None,
189            token_provider: None,
190        }
191    }
192
193    pub fn http_client(mut self, client: reqwest::Client) -> Self {
194        self.http_client = Some(client);
195        self
196    }
197
198    pub fn token_provider(mut self, provider: Box<dyn TokenProvider>) -> Self {
199        self.token_provider = Some(provider);
200        self
201    }
202
203    pub fn build(self) -> Result<GmailClient, String> {
204        let http_client = self.http_client.unwrap_or_else(|| reqwest::Client::new());
205        let token_provider = self.token_provider.ok_or("Token provider is required")?;
206
207        Ok(GmailClient {
208            http_client,
209            token_provider,
210        })
211    }
212}
213
214fn parse_from_header(from: &str) -> (Option<String>, Option<String>) {
215    // Parse "Name <email@example.com>" or "email@example.com"
216    if let Some(start) = from.find('<') {
217        if let Some(end) = from.find('>') {
218            let email = from[start + 1..end].trim().to_string();
219            let name = from[..start].trim().trim_matches('"').to_string();
220            return (Some(email), if name.is_empty() { None } else { Some(name) });
221        }
222    }
223
224    // If no angle brackets, assume it's just an email
225    (Some(from.trim().to_string()), None)
226}
227
228fn extract_body(part: &GmailMessagePart, parsed: &mut ParsedEmail) {
229    if let Some(ref parts) = part.parts {
230        for p in parts {
231            extract_body(p, parsed);
232        }
233    }
234
235    if let Some(ref body) = part.body {
236        if let Some(ref data) = body.data {
237            use base64::{engine::general_purpose, Engine as _};
238            let decoded = general_purpose::STANDARD
239                .decode(data.replace("-", "+").replace("_", "/"))
240                .ok()
241                .and_then(|bytes| String::from_utf8(bytes).ok());
242
243            if let Some(decoded) = decoded {
244                match part.mime_type.as_deref() {
245                    Some("text/html") => {
246                        parsed.body_html = Some(decoded);
247                    }
248                    Some("text/plain") => {
249                        parsed.body_text = Some(decoded);
250                    }
251                    _ => {}
252                }
253            }
254        }
255    }
256}