Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
//! 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,
}))
}