aiagent/backend/app/api/tasks.py

"""
Task API — 任务管理接口
"""
from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session
from pydantic import BaseModel, Field
from typing import List, Optional, Dict, Any
from datetime import datetime
import logging

from app.core.database import get_db
from app.api.auth import get_current_user
from app.models.user import User
from app.services import goal_service

logger = logging.getLogger(__name__)

router = APIRouter(
    prefix="/api/v1/tasks",
    tags=["tasks"],
    responses={
        401: {"description": "未授权"},
        404: {"description": "资源不存在"},
        400: {"description": "请求参数错误"},
    },
)


# ──────────────────────────── Schemas ────────────────────────────

class TaskCreate(BaseModel):
    goal_id: str
    title: str
    description: str = ""
    priority: int = Field(default=5, ge=1, le=10)
    parent_task_id: Optional[str] = None
    depends_on: Optional[List[str]] = None
    assigned_agent_id: Optional[str] = None
    assigned_agent_name: Optional[str] = None
    task_config: Optional[Dict[str, Any]] = None
    deadline: Optional[datetime] = None
    requires_approval: bool = False
    approver_id: Optional[str] = None


class TaskUpdate(BaseModel):
    title: Optional[str] = None
    description: Optional[str] = None
    status: Optional[str] = None
    priority: Optional[int] = Field(default=None, ge=1, le=10)
    task_config: Optional[Dict[str, Any]] = None
    depends_on: Optional[List[str]] = None
    assigned_agent_id: Optional[str] = None
    assigned_agent_name: Optional[str] = None
    result: Optional[Dict[str, Any]] = None
    error_message: Optional[str] = None
    execution_id: Optional[str] = None
    deadline: Optional[datetime] = None


class TaskResponse(BaseModel):
    id: str
    goal_id: str
    title: str
    description: Optional[str]
    status: str
    priority: int
    task_config: Optional[Any]
    parent_task_id: Optional[str]
    depends_on: Optional[Any]
    result: Optional[Any]
    error_message: Optional[str]
    execution_id: Optional[str]
    assigned_agent_id: Optional[str]
    assigned_agent_name: Optional[str]
    requires_approval: bool
    approver_id: Optional[str]
    approval_status: Optional[str]
    started_at: Optional[datetime]
    completed_at: Optional[datetime]
    deadline: Optional[datetime]
    created_at: datetime
    updated_at: datetime

    class Config:
        from_attributes = True


class TaskDependencyCheck(BaseModel):
    task_id: str
    dependencies_met: bool
    pending_dependencies: List[str] = []


# ──────────────────────────── Endpoints ────────────────────────────

@router.post("", response_model=TaskResponse, status_code=201)
def create_task(
    data: TaskCreate,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """创建新任务"""
    return goal_service.create_task(
        db=db,
        goal_id=data.goal_id,
        title=data.title,
        description=data.description,
        priority=data.priority,
        parent_task_id=data.parent_task_id,
        depends_on=data.depends_on,
        assigned_agent_id=data.assigned_agent_id,
        assigned_agent_name=data.assigned_agent_name,
        task_config=data.task_config,
        deadline=data.deadline,
        requires_approval=data.requires_approval,
        approver_id=data.approver_id,
    )


@router.get("", response_model=List[TaskResponse])
def list_tasks(
    goal_id: Optional[str] = None,
    status: Optional[str] = None,
    assigned_agent_id: Optional[str] = None,
    parent_task_id: Optional[str] = None,
    skip: int = Query(default=0, ge=0),
    limit: int = Query(default=50, ge=1, le=200),
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """列出任务"""
    return goal_service.list_tasks(
        db=db,
        goal_id=goal_id,
        status=status,
        assigned_agent_id=assigned_agent_id,
        parent_task_id=parent_task_id,
        skip=skip,
        limit=limit,
    )


@router.get("/{task_id}", response_model=TaskResponse)
def get_task(
    task_id: str,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """获取任务详情"""
    return goal_service.get_task(db, task_id)


@router.put("/{task_id}", response_model=TaskResponse)
def update_task(
    task_id: str,
    data: TaskUpdate,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """更新任务"""
    return goal_service.update_task(
        db=db,
        task_id=task_id,
        title=data.title,
        description=data.description,
        status=data.status,
        priority=data.priority,
        task_config=data.task_config,
        depends_on=data.depends_on,
        assigned_agent_id=data.assigned_agent_id,
        assigned_agent_name=data.assigned_agent_name,
        result=data.result,
        error_message=data.error_message,
        execution_id=data.execution_id,
        deadline=data.deadline,
    )


@router.delete("/{task_id}", status_code=204)
def delete_task(
    task_id: str,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """删除任务"""
    goal_service.delete_task(db, task_id)
    return None


@router.get("/{task_id}/check-dependencies", response_model=TaskDependencyCheck)
def check_task_dependencies(
    task_id: str,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """检查任务的前置依赖是否满足"""
    met = goal_service.get_task_dependencies_met(db, task_id)
    task = goal_service.get_task(db, task_id)
    pending = []
    if not met:
        for dep_id in (task.depends_on or []):
            from app.models.task import Task
            dep = db.query(Task).filter(Task.id == dep_id).first()
            if dep and dep.status != "completed":
                pending.append(dep_id)
    return TaskDependencyCheck(
        task_id=task_id,
        dependencies_met=met,
        pending_dependencies=pending,
    )


@router.post("/{task_id}/approve", response_model=TaskResponse)
def approve_task(
    task_id: str,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """审批通过任务"""
    return goal_service.update_task(
        db=db,
        task_id=task_id,
        status="in_progress",
    )


@router.post("/{task_id}/reject", response_model=TaskResponse)
def reject_task(
    task_id: str,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """审批驳回任务"""
    return goal_service.update_task(
        db=db,
        task_id=task_id,
        status="failed",
        error_message="审批驳回",
    )


@router.post("/{task_id}/execute", response_model=TaskResponse)
async def execute_task(
    task_id: str,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """手动执行任务 — 通过 Main Agent 服务执行单个任务"""
    from app.services.main_agent_service import MainAgentService
    goal_service.update_task(db=db, task_id=task_id, status="in_progress")
    try:
        svc = MainAgentService(db)
        result = await svc.execute_task(task_id)
        goal_service.update_task(
            db=db,
            task_id=task_id,
            status="completed",
            result=result,
        )
    except Exception as e:
        logger.error("任务 %s 执行失败: %s", task_id, e)
        goal_service.update_task(
            db=db,
            task_id=task_id,
            status="failed",
            error_message=str(e),
        )
    return goal_service.get_task(db, task_id)


@router.post("/{task_id}/retry", response_model=TaskResponse)
async def retry_task(
    task_id: str,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """重试失败任务"""
    task = goal_service.get_task(db, task_id)
    if task.status != "failed":
        from fastapi import HTTPException
        raise HTTPException(400, "只能重试失败状态的任务")
    goal_service.update_task(
        db=db,
        task_id=task_id,
        status="pending",
        error_message=None,
        result=None,
    )
    from app.services.main_agent_service import MainAgentService
    goal_service.update_task(db=db, task_id=task_id, status="in_progress")
    try:
        svc = MainAgentService(db)
        result = await svc.execute_task(task_id)
        goal_service.update_task(
            db=db,
            task_id=task_id,
            status="completed",
            result=result,
        )
    except Exception as e:
        logger.error("任务 %s 重试失败: %s", task_id, e)
        goal_service.update_task(
            db=db,
            task_id=task_id,
            status="failed",
            error_message=str(e),
        )
    return goal_service.get_task(db, task_id)