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.7 KB
Raw Blame
//! Handler for `POST /documents/create_task`.

use axum::{Json, extract::State};
use base64::Engine;
use entity_access::domain::models::MemberTeamRole;
use entity_access::domain::ports::EntityAccessService;
use entity_access::inbound::axum_extractors::{
    OptionalMacroUserTeamExtractorV2, ProjectBodyAccessLevelExtractorV2,
};
use entity_registry::CreationPrincipalExtractor;
use macro_authorization::MacroAuthorizationService;
use models_permissions::share_permission::access_level::{AccessLevel, EditAccessLevel};

use super::DocumentRouterState;
use crate::domain::create::{MarkdownSubtype, NewDocumentMetadata, NewMarkdownTextDocument};
use crate::domain::models::{CreateTaskRequest, CreateTaskResponse, DocumentError};
use crate::domain::permission_token::encode_principal_permission_token;
use crate::domain::ports::DocumentService;
use crate::domain::ports::create::DocumentCreationService;
use task_dedup::{EmbeddingMarkdown, NewTask};

use super::task_duplicates::spawn_task_duplicate_detection;

/// Creates a task document with properties and initialized markdown content in
/// one backend-owned lifecycle.
#[utoipa::path(
    tag = "document",
    post,
    path = "/documents/create_task",
    request_body = CreateTaskRequest,
    responses(
        (status = 200, body = inline(CreateTaskResponse)),
        (status = 400, body = model_error_response::ErrorResponse),
        (status = 401, body = model_error_response::ErrorResponse),
        (status = 500, body = model_error_response::ErrorResponse),
    )
)]
#[tracing::instrument(skip(state, optional_team, project))]
pub async fn create_task_handler<
    T: DocumentService + DocumentCreationService,
    Svc: EntityAccessService,
    Auth: MacroAuthorizationService,
>(
    State(state): State<DocumentRouterState<T, Svc, Auth>>,
    CreationPrincipalExtractor { principal, .. }: CreationPrincipalExtractor<Auth>,
    optional_team: OptionalMacroUserTeamExtractorV2<MemberTeamRole, Svc, Auth>,
    project: ProjectBodyAccessLevelExtractorV2<EditAccessLevel, CreateTaskRequest, Svc, Auth>,
) -> Result<Json<CreateTaskResponse>, DocumentError> {
    let req = project.into_inner();
    let task_name = req.task_name.clone();
    let markdown = req.markdown.clone().unwrap_or_default();

    let mut metadata = NewDocumentMetadata::builder(task_name.clone());
    if let Some(project_id) = req.project_id {
        metadata = metadata.project_id(project_id);
    }

    let team_id = if req.share_with_team {
        optional_team
            .entity_access_receipt
            .map(|team| macro_uuid::string_to_uuid(&team.entity().entity_id).unwrap())
    } else {
        None
    };

    let created = state
        .creator
        .create_markdown_text(
            &principal,
            NewMarkdownTextDocument {
                metadata: metadata.build(),
                markdown,
                subtype: MarkdownSubtype::Task {
                    property_values: req.property_values,
                    share_with_team: req.share_with_team && team_id.is_some(), // we should only try and share if the user is in a team and they have share_with_team set
                    team_id,
                },
            },
        )
        .await?;

    let task_metadata = &created.response().document_response.document_metadata;
    let document_id = created.document_id().to_string();
    let initial_snapshot = created.initial_snapshot().ok_or_else(|| {
        DocumentError::Internal(anyhow::anyhow!(
            "markdown creation did not return its initial snapshot"
        ))
    })?;
    let initial_snapshot = base64::engine::general_purpose::STANDARD.encode(initial_snapshot);
    spawn_task_duplicate_detection(
        state.task_dedup_service.clone(),
        state.lexical_client.clone(),
        NewTask {
            document_id: document_id.clone(),
            owner: principal.owner().principal_id(),
            team_id: task_metadata.team_id,
            title: task_name,
            // Filled from lexical (embedding format) inside the spawn; defaults
            // to title-only so a failed render never embeds wrong-format text.
            markdown: EmbeddingMarkdown::empty(),
        },
    );

    let token = encode_principal_permission_token(
        &principal,
        document_id.clone(),
        AccessLevel::Edit,
        &state.document_permission_jwt_secret,
    )
    .map_err(|e| {
        tracing::error!(error=?e, "failed to encode permission token");
        DocumentError::Internal(e.into())
    })?
    .into_inner();

    Ok(Json(CreateTaskResponse {
        document_id,
        document_metadata: task_metadata.metadata.clone(),
        token,
        initial_snapshot,
        team_id: task_metadata.team_id,
        team_task_id: task_metadata.team_task_id,
    }))
}