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.

4.6 KB
Raw Blame
use std::sync::Arc;

use entity_access::domain::ports::EntityAccessService as _;
use macro_user_id::cowlike::CowLike;
use macro_user_id::user_id::MacroUserIdStr;
use models_properties::DataType;
use models_properties::service::property_option::PropertyOptionValue;

use super::{ToolEntityAccessService, ToolPropertiesService};

#[derive(Clone)]
pub struct ToolActivityMetadataResolver {
    properties: Arc<ToolPropertiesService>,
    entity_access_service: Arc<ToolEntityAccessService>,
}

impl ToolActivityMetadataResolver {
    pub(super) fn new(
        properties: Arc<ToolPropertiesService>,
        entity_access_service: Arc<ToolEntityAccessService>,
    ) -> Self {
        Self {
            properties,
            entity_access_service,
        }
    }
}

#[async_trait::async_trait]
impl activity::ActivityMetadataResolver for ToolActivityMetadataResolver {
    async fn resolve_properties(
        &self,
        viewer: &MacroUserIdStr<'_>,
        property_ids: &[String],
    ) -> std::collections::HashMap<String, activity::ActivityPropertyMetadata> {
        use entity_access::domain::models::{
            Entity, EntityAccessReceipt, EntityPermission, EntityType,
        };
        use properties::domain::service::PropertiesService as _;

        if property_ids.is_empty() {
            return std::collections::HashMap::new();
        }

        let team = match self.entity_access_service.get_user_team(viewer).await {
            Ok(Some(team_info)) => {
                let viewer = viewer.copied().into_owned();
                match EntityAccessReceipt::try_new_authenticated_user(
                    viewer,
                    Entity {
                        entity_id: team_info.team_id.to_string(),
                        entity_type: EntityType::Team,
                    },
                    EntityPermission::TeamRole {
                        role: team_info.role,
                    },
                ) {
                    Ok(receipt) => Some(receipt),
                    Err(error) => {
                        tracing::warn!(error=?error, "failed to mint activity metadata team receipt");
                        return std::collections::HashMap::new();
                    }
                }
            }
            Ok(None) => None,
            Err(error) => {
                tracing::warn!(error=?error, "failed to resolve activity metadata team");
                return std::collections::HashMap::new();
            }
        };

        let definitions = match self
            .properties
            .list_property_definitions_with_options(team.as_ref(), Some(viewer), true, None)
            .await
        {
            Ok(definitions) => definitions,
            Err(error) => {
                tracing::warn!(error=?error, "failed to resolve activity property metadata");
                return std::collections::HashMap::new();
            }
        };
        let requested: std::collections::HashSet<&str> =
            property_ids.iter().map(String::as_str).collect();

        definitions
            .into_iter()
            .filter_map(|definition| {
                let id = definition.definition.id.to_string();
                if !requested.contains(id.as_str()) {
                    return None;
                }
                let data_type = property_data_type_name(definition.definition.data_type);
                let option_labels = definition
                    .property_options
                    .into_iter()
                    .map(|option| {
                        let label = match option.value {
                            PropertyOptionValue::String(value) => value,
                            PropertyOptionValue::Number(value) => value.to_string(),
                        };
                        (option.id.to_string(), label)
                    })
                    .collect();
                Some((
                    id,
                    activity::ActivityPropertyMetadata {
                        display_name: definition.definition.display_name,
                        data_type: data_type.to_string(),
                        option_labels,
                    },
                ))
            })
            .collect()
    }
}

fn property_data_type_name(data_type: DataType) -> &'static str {
    match data_type {
        DataType::Boolean => "boolean",
        DataType::Date => "date",
        DataType::DateRange => "date_range",
        DataType::Number => "number",
        DataType::String => "string",
        DataType::SelectNumber => "select_number",
        DataType::SelectString => "select_string",
        DataType::Tag => "tag",
        DataType::Entity => "entity",
        DataType::Link => "link",
    }
}