Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

8.0 KB
Raw Blame
//! Gmail message capability implementation.

use std::collections::HashMap;

use base64::{
    Engine as _,
    engine::general_purpose::{URL_SAFE, URL_SAFE_NO_PAD},
};
use models_email::email::service::thread::ThreadSummary;
use models_email::gmail::MessagePart;
use uuid::Uuid;

use crate::domain::models::{
    AccessToken, CalendarPart, EmailApiError, MessageWithCalendarParts, ThreadListPage,
};
use crate::domain::ports::{MailboxCalendarClient, MailboxMessageClient, MailboxRawMessageClient};

use super::convert::{map_message_resource_to_service, map_thread_resource_to_service};
use super::{GmailApiClientRepository, map_gmail_error};

impl MailboxCalendarClient for GmailApiClientRepository {
    async fn get_calendar_parts(
        &self,
        access_token: &AccessToken,
        provider_message_id: &str,
    ) -> Result<Vec<CalendarPart>, EmailApiError> {
        let Some(message) = self
            .client
            .get_message(access_token.expose_secret(), provider_message_id)
            .await
            .map_err(map_gmail_error)?
        else {
            return Ok(Vec::new());
        };

        collect_calendar_parts(&message.payload)
    }
}

impl MailboxRawMessageClient for GmailApiClientRepository {
    async fn get_raw_message(
        &self,
        access_token: &AccessToken,
        provider_message_id: &str,
    ) -> Result<Vec<u8>, EmailApiError> {
        self.client
            .get_raw_message(access_token.expose_secret(), provider_message_id)
            .await
            .map_err(map_gmail_error)?
            .ok_or(EmailApiError::NotFound)
    }
}

fn collect_calendar_parts(root: &MessagePart) -> Result<Vec<CalendarPart>, EmailApiError> {
    let mut result = Vec::new();
    let mut stack = vec![root];
    while let Some(part) = stack.pop() {
        let mime_type = part.mime_type.split(';').next().unwrap_or_default().trim();
        let is_calendar = mime_type.eq_ignore_ascii_case("text/calendar")
            || mime_type.eq_ignore_ascii_case("application/ics")
            || part.filename.to_ascii_lowercase().ends_with(".ics");
        if is_calendar {
            let body = part.body.as_ref();
            let inline_data =
                body.and_then(|body| body.data_base64.as_deref())
                    .and_then(|encoded| {
                        URL_SAFE_NO_PAD
                            .decode(encoded)
                            .or_else(|_| URL_SAFE.decode(encoded))
                            .ok()
                    });
            result.push(CalendarPart {
                part_id: (!part.part_id.is_empty()).then(|| part.part_id.clone()),
                filename: (!part.filename.is_empty()).then(|| part.filename.clone()),
                mime_type: part.mime_type.clone(),
                inline_data,
                provider_attachment_id: body.and_then(|body| body.attachment_id.clone()),
            });
        }
        if let Some(children) = &part.parts {
            stack.extend(children);
        }
    }
    Ok(result)
}

impl MailboxMessageClient for GmailApiClientRepository {
    async fn get_message(
        &self,
        access_token: &AccessToken,
        link_id: Uuid,
        provider_message_id: &str,
    ) -> Result<Option<MessageWithCalendarParts>, EmailApiError> {
        let Some(resource) = self
            .client
            .get_message(access_token.expose_secret(), provider_message_id)
            .await
            .map_err(map_gmail_error)?
        else {
            return Ok(None);
        };

        // Extract calendar parts from the wire resource we already hold so
        // ingest never needs a second messages.get for the same message.
        let calendar_parts = collect_calendar_parts(&resource.payload)?;
        let message = map_message_resource_to_service(resource, link_id)?;

        Ok(Some(MessageWithCalendarParts {
            message,
            calendar_parts,
        }))
    }

    async fn get_message_label_ids(
        &self,
        access_token: &AccessToken,
        provider_message_id: &str,
    ) -> Result<Option<Vec<String>>, EmailApiError> {
        self.client
            .get_message_label_ids(access_token.expose_secret(), provider_message_id)
            .await
            .map_err(map_gmail_error)
    }

    async fn list_messages(
        &self,
        access_token: &AccessToken,
        limit: u32,
        label_ids: &[&str],
    ) -> Result<Vec<String>, EmailApiError> {
        self.client
            .list_messages(access_token.expose_secret(), limit, label_ids)
            .await
            .map_err(map_gmail_error)
    }

    async fn get_message_ids_for_thread(
        &self,
        access_token: &AccessToken,
        provider_thread_id: &str,
    ) -> Result<Vec<String>, EmailApiError> {
        self.client
            .get_message_ids_for_thread(access_token.expose_secret(), provider_thread_id)
            .await
            .map_err(map_gmail_error)
    }

    async fn get_thread(
        &self,
        access_token: &AccessToken,
        link_id: Uuid,
        provider_thread_id: &str,
    ) -> Result<Vec<MessageWithCalendarParts>, EmailApiError> {
        let resource = self
            .client
            .get_thread(access_token.expose_secret(), provider_thread_id)
            .await
            .map_err(map_gmail_error)?;
        // Collect calendar parts from the wire messages before conversion
        // consumes them, so a thread read needs no messages.get per message.
        let mut calendar_parts = resource
            .messages
            .iter()
            .map(|message| {
                Ok((
                    message.id.clone(),
                    collect_calendar_parts(&message.payload)?,
                ))
            })
            .collect::<Result<HashMap<_, _>, EmailApiError>>()?;
        Ok(map_thread_resource_to_service(resource, link_id)?
            .messages
            .into_iter()
            .map(|message| MessageWithCalendarParts {
                calendar_parts: message
                    .provider_id
                    .as_ref()
                    .and_then(|id| calendar_parts.remove(id))
                    .unwrap_or_default(),
                message,
            })
            .collect())
    }

    async fn list_threads(
        &self,
        access_token: &AccessToken,
        limit: u32,
        next_page_token: Option<&str>,
        label_ids: &[&str],
    ) -> Result<ThreadListPage, EmailApiError> {
        let response = self
            .client
            .list_threads(
                access_token.expose_secret(),
                limit,
                next_page_token,
                label_ids,
            )
            .await
            .map_err(map_gmail_error)?;
        Ok(ThreadListPage {
            threads: response
                .threads
                .unwrap_or_default()
                .into_iter()
                .map(|thread| ThreadSummary {
                    provider_id: thread.id,
                })
                .collect(),
            next_page_token: response.next_page_token,
        })
    }

    async fn modify_message_labels(
        &self,
        access_token: &AccessToken,
        provider_message_id: &str,
        label_ids_to_add: &[String],
        label_ids_to_remove: &[String],
    ) -> Result<(), EmailApiError> {
        self.client
            .modify_message_labels(
                access_token.expose_secret(),
                provider_message_id,
                label_ids_to_add,
                label_ids_to_remove,
            )
            .await
            .map_err(map_gmail_error)
    }

    async fn batch_modify_message_labels(
        &self,
        access_token: &AccessToken,
        provider_message_ids: &[String],
        label_ids_to_add: &[String],
        label_ids_to_remove: &[String],
    ) -> Result<(), EmailApiError> {
        self.client
            .batch_modify_message_labels(
                access_token.expose_secret(),
                provider_message_ids,
                label_ids_to_add,
                label_ids_to_remove,
            )
            .await
            .map_err(map_gmail_error)
    }
}