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.

3.9 KB
Raw Blame
//! Gmail blocked-sender capability implementation.

use models_email::gmail::filters::{Filter, FilterAction, FilterCriteria};

use crate::domain::models::{AccessToken, EmailApiError};
use crate::domain::ports::MailboxBlocklistClient;

use super::{GmailApiClientRepository, map_gmail_error};

const TRASH_LABEL_ID: &str = "TRASH";

impl MailboxBlocklistClient for GmailApiClientRepository {
    async fn block_sender(
        &self,
        access_token: &AccessToken,
        email_address: &str,
    ) -> Result<(), EmailApiError> {
        let token = access_token.expose_secret();
        let filters = self
            .client
            .list_filters(token)
            .await
            .map_err(map_gmail_error)?;
        if find_block_filters(&filters, email_address).next().is_some() {
            return Ok(());
        }

        self.client
            .create_filter(token, block_filter(email_address))
            .await
            .map_err(map_gmail_error)?;
        Ok(())
    }

    async fn unblock_sender(
        &self,
        access_token: &AccessToken,
        email_address: &str,
    ) -> Result<(), EmailApiError> {
        let token = access_token.expose_secret();
        let filters = self
            .client
            .list_filters(token)
            .await
            .map_err(map_gmail_error)?;
        // Delete every matching filter: blocking with different casing used to
        // create duplicates, and removing them all heals those legacy states.
        let mut found = false;
        for filter in find_block_filters(&filters, email_address) {
            found = true;
            let Some(filter_id) = filter.id.as_deref() else {
                return Err(EmailApiError::Permanent {
                    message: "Gmail blocked-sender filter is missing its provider ID".to_string(),
                });
            };

            self.client
                .delete_filter(token, filter_id)
                .await
                .map_err(map_gmail_error)?;
        }

        if !found {
            tracing::warn!("no blocked-sender filter found to delete for the requested address");
        }

        Ok(())
    }

    async fn list_blocked_senders(
        &self,
        access_token: &AccessToken,
    ) -> Result<Vec<String>, EmailApiError> {
        let filters = self
            .client
            .list_filters(access_token.expose_secret())
            .await
            .map_err(map_gmail_error)?;

        Ok(filters
            .iter()
            .filter(|filter| is_block_filter(filter))
            .filter_map(|filter| filter.criteria.from.clone())
            .collect())
    }
}

fn block_filter(email_address: &str) -> Filter {
    Filter {
        id: None,
        criteria: FilterCriteria {
            from: Some(email_address.to_string()),
            to: None,
            subject: None,
            query: None,
            negated_query: None,
            has_attachment: None,
            exclude_chats: None,
        },
        action: FilterAction {
            add_label_ids: Some(vec![TRASH_LABEL_ID.to_string()]),
            remove_label_ids: None,
            forward: None,
        },
    }
}

/// Finds every block filter for `email_address`, ignoring ASCII case: Gmail
/// treats addresses case-insensitively and stored filters may differ in
/// casing from the request.
fn find_block_filters<'a>(
    filters: &'a [Filter],
    email_address: &'a str,
) -> impl Iterator<Item = &'a Filter> {
    filters.iter().filter(move |filter| {
        is_block_filter(filter)
            && filter
                .criteria
                .from
                .as_deref()
                .is_some_and(|from| from.eq_ignore_ascii_case(email_address))
    })
}

fn is_block_filter(filter: &Filter) -> bool {
    filter.criteria.from.is_some()
        && filter
            .action
            .add_label_ids
            .as_ref()
            .is_some_and(|label_ids| label_ids.iter().any(|label_id| label_id == TRASH_LABEL_ID))
}