652 lines
24 KiB
Python
652 lines
24 KiB
Python
"""外部系统限界上下文 - Tool 子域 Router。
|
||
|
||
挂载到聚合 router 的 /tools 前缀下，覆盖工具 CRUD / 批量导入 / 克隆 / 版本 /
|
||
导入导出 / WSDL 导入导出 / 执行入口 / ``get_enabled_tools`` / ``list_tool_options``，
|
||
以及 tool_router 扩展端点（版本对比 / 版本回滚 / 参数模板 / 批量执行 /
|
||
批量克隆 / 执行趋势 / 依赖资产）。Request Schema 与 Input DTO 不共享类，
|
||
Router 内显式构造 DTO，操作人字段由 current_user.uid 填充。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
from datetime import UTC, datetime
|
||
from typing import Any, Literal
|
||
|
||
from fastapi import APIRouter, Depends, Query
|
||
from fastapi.responses import StreamingResponse
|
||
from pydantic import BaseModel, ConfigDict, Field
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
from yuxi.external_systems.infrastructure.container import create_use_cases_from_db
|
||
from yuxi.external_systems.use_cases.dto.tool import (
|
||
BatchCloneToolsInput,
|
||
BatchExecuteToolItem,
|
||
BatchExecuteToolsInput,
|
||
BatchImportToolsInput,
|
||
CloneToolInput,
|
||
CompareToolVersionsInput,
|
||
CreateToolInput,
|
||
DeleteToolInput,
|
||
ExecuteToolInput,
|
||
ExportToolsInput,
|
||
ExportWsdlInput,
|
||
ExternalToolCreateInput,
|
||
GetEnabledToolsInput,
|
||
GetToolAssetsInput,
|
||
GetToolExecutionTrendInput,
|
||
GetToolInput,
|
||
GetToolParameterTemplateInput,
|
||
GetToolVersionsInput,
|
||
HealthCheckToolInput,
|
||
ImportWsdlInput,
|
||
ListToolOptionsInput,
|
||
ListToolsInput,
|
||
RollbackToolVersionInput,
|
||
UpdateToolInput,
|
||
)
|
||
from yuxi.storage.postgres.models_business import User
|
||
|
||
from server.utils.auth_middleware import get_admin_user, get_db, get_required_user
|
||
|
||
tool_router = APIRouter(prefix="/tools", tags=["external-systems-tool"])
|
||
|
||
|
||
# =============================================================================
|
||
# === Request Schemas（与 Input DTO 不共享类） ===
|
||
# =============================================================================
|
||
|
||
|
||
class CreateToolRequest(BaseModel):
|
||
"""创建工具请求体。字段对齐 ``CreateToolInput``（不含 created_by）。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
slug: str = Field(..., min_length=1, max_length=128, pattern=r"^[a-zA-Z_][a-zA-Z0-9_-]{0,127}$")
|
||
name: str = Field(..., min_length=1, max_length=128)
|
||
description: str = ""
|
||
category: str = Field(default="default", max_length=64)
|
||
adapter_type: str = Field(default="http", max_length=32)
|
||
auth_type: str = Field(default="none", max_length=32)
|
||
adapter_config: dict[str, Any] = Field(default_factory=dict)
|
||
auth_config: dict[str, Any] | None = None
|
||
timeout: int = Field(default=30, ge=1, le=300)
|
||
retry_policy: dict[str, Any] = Field(default_factory=dict)
|
||
enabled: bool = True
|
||
system_id: int | None = None
|
||
|
||
|
||
class UpdateToolRequest(BaseModel):
|
||
"""更新工具请求体。字段对齐 ``UpdateToolInput``（不含 id 与 updated_by）。
|
||
|
||
字段长度约束对齐 ``CreateToolRequest``，仅透传客户端显式设置的字段
|
||
（通过 ``exclude_unset=True``），未设置字段保持 ``None`` 以保留部分更新语义。
|
||
"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
name: str | None = Field(default=None, min_length=1, max_length=128)
|
||
description: str | None = None
|
||
category: str | None = Field(default=None, max_length=64)
|
||
adapter_type: str | None = Field(default=None, max_length=32)
|
||
auth_type: str | None = Field(default=None, max_length=32)
|
||
adapter_config: dict[str, Any] | None = None
|
||
auth_config: dict[str, Any] | None = None
|
||
timeout: int | None = Field(default=None, ge=1, le=300)
|
||
retry_policy: dict[str, Any] | None = None
|
||
enabled: bool | None = None
|
||
system_id: int | None = None
|
||
|
||
|
||
class CloneToolRequest(BaseModel):
|
||
"""克隆工具请求体。字段对齐 ``CloneToolInput``（不含 id 与 created_by）。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
new_slug: str = Field(..., min_length=1, max_length=128, pattern=r"^[a-zA-Z_][a-zA-Z0-9_-]{0,127}$")
|
||
new_name: str | None = Field(default=None, min_length=1, max_length=128)
|
||
system_id: int | None = None
|
||
|
||
|
||
class ExternalToolItemRequest(BaseModel):
|
||
"""外部工具项请求体。字段对齐 ``ExternalToolCreateInput``。
|
||
|
||
用于批量导入工具（``BatchImportToolsRequest.tools``）。
|
||
"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
slug: str = Field(..., min_length=1, max_length=128, pattern=r"^[a-zA-Z_][a-zA-Z0-9_-]{0,127}$")
|
||
name: str = Field(..., min_length=1, max_length=128)
|
||
description: str = Field(..., min_length=1)
|
||
category: str = Field(default="default", max_length=64)
|
||
adapter_type: str = Field(default="http", max_length=32)
|
||
enabled: bool = True
|
||
timeout: int = Field(default=30, ge=1, le=300)
|
||
retry_policy: dict[str, Any] = Field(default_factory=dict)
|
||
auth_type: str = Field(default="none", max_length=32)
|
||
auth_config: dict[str, Any] = Field(default_factory=dict)
|
||
adapter_config: dict[str, Any] = Field(default_factory=dict)
|
||
|
||
|
||
class BatchImportToolsRequest(BaseModel):
|
||
"""批量导入工具请求体。字段对齐 ``BatchImportToolsInput``。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
system_id: int | None = None
|
||
tools: list[ExternalToolItemRequest] = Field(default_factory=list)
|
||
|
||
|
||
class ImportWsdlRequest(BaseModel):
|
||
"""导入 WSDL 请求体。字段对齐 ``ImportWsdlInput``（不含 created_by）。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
wsdl_url: str | None = None
|
||
wsdl_content: str | None = None
|
||
system_id: int | None = None
|
||
|
||
|
||
class ExecuteToolRequest(BaseModel):
|
||
"""执行工具请求体。字段对齐 ``ExecuteToolInput``（不含 caller，由服务端填充）。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
tool_slug: str
|
||
system_id: int | None = None
|
||
env_key: str = "default"
|
||
arguments: dict[str, Any] = Field(default_factory=dict)
|
||
caller_id: str | None = None
|
||
correlation_id: str | None = None
|
||
tags: dict[str, Any] = Field(default_factory=dict)
|
||
|
||
|
||
class HealthCheckToolRequest(BaseModel):
|
||
"""触发工具健康检查请求体。字段对齐 ``HealthCheckToolInput``。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
env_key: str | None = Field(default=None, max_length=32)
|
||
|
||
|
||
class BatchExecuteToolItemRequest(BaseModel):
|
||
"""批量执行工具项请求体。字段对齐 ``BatchExecuteToolItem``。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
tool_slug: str
|
||
system_id: int | None = None
|
||
env_key: str = "default"
|
||
arguments: dict[str, Any] = Field(default_factory=dict)
|
||
caller_id: str | None = None
|
||
correlation_id: str | None = None
|
||
tags: dict[str, Any] = Field(default_factory=dict)
|
||
|
||
|
||
class BatchExecuteToolsRequest(BaseModel):
|
||
"""批量执行工具请求体。字段对齐 ``BatchExecuteToolsInput``（不含 caller，由服务端填充）。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
executions: list[BatchExecuteToolItemRequest] = Field(default_factory=list)
|
||
|
||
|
||
class BatchCloneToolsRequest(BaseModel):
|
||
"""批量克隆工具请求体。字段对齐 ``BatchCloneToolsInput``（不含 created_by，由服务端填充）。"""
|
||
|
||
model_config = ConfigDict(frozen=True)
|
||
|
||
source_tool_ids: list[int]
|
||
slug_suffix: str = Field(..., min_length=1, max_length=64)
|
||
override_config: dict[str, Any] = Field(default_factory=dict)
|
||
|
||
|
||
# =============================================================================
|
||
# === 静态路径端点（必须在 /{tool_id} 之前声明） ===
|
||
# =============================================================================
|
||
|
||
|
||
@tool_router.get("/enabled", response_model=dict)
|
||
async def get_enabled_tools(
|
||
system_id: int | None = Query(None),
|
||
env_key: str | None = Query(None),
|
||
category: str | None = Query(None),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""获取已启用工具列表（供 agents 模块使用）。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = GetEnabledToolsInput(system_id=system_id, env_key=env_key, category=category)
|
||
output = await use_cases.tool_service.get_enabled_tools(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.get("/options", response_model=dict)
|
||
async def list_tool_options(
|
||
system_id: int | None = Query(None),
|
||
category: str | None = Query(None),
|
||
enabled_only: bool = Query(True),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""列出工具选项（供下拉选择使用）。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = ListToolOptionsInput(
|
||
system_id=system_id,
|
||
category=category,
|
||
enabled_only=enabled_only,
|
||
)
|
||
output = await use_cases.tool_service.list_tool_options(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.get("/export")
|
||
async def export_tools(
|
||
system_id: int | None = Query(None),
|
||
ids: list[int] | None = Query(None),
|
||
category: str | None = Query(None),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> StreamingResponse:
|
||
"""导出工具列表为 JSON 字节流。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = ExportToolsInput(system_id=system_id, ids=ids, category=category)
|
||
output = await use_cases.tool_service.export_tools(input_dto)
|
||
|
||
payload = json.dumps(
|
||
[item.model_dump() for item in output.items],
|
||
ensure_ascii=False,
|
||
default=str,
|
||
).encode("utf-8")
|
||
timestamp = datetime.now(UTC).strftime("%Y%m%d%H%M%S")
|
||
|
||
async def _stream():
|
||
yield payload
|
||
|
||
return StreamingResponse(
|
||
_stream(),
|
||
media_type="application/octet-stream",
|
||
headers={"Content-Disposition": f"attachment; filename=tools_{timestamp}.json"},
|
||
)
|
||
|
||
|
||
@tool_router.get("/export-wsdl", response_model=dict)
|
||
async def export_wsdl(
|
||
system_id: int = Query(..., description="目标外部系统 ID"),
|
||
tool_slug: str | None = Query(None, description="指定工具 slug，未指定则取系统下首个 SOAP 工具"),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""导出 WSDL 内容。
|
||
|
||
从指定系统下的 SOAP 工具提取 ``wsdl_content``；若工具仅存储 ``wsdl_url``，
|
||
则通过 SOAP 适配器加载后返回。``system_id`` 为必填，``tool_slug`` 可选。
|
||
"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = ExportWsdlInput(system_id=system_id, tool_slug=tool_slug)
|
||
output = await use_cases.tool_service.export_wsdl(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.post("/import", response_model=dict)
|
||
async def batch_import_tools(
|
||
body: BatchImportToolsRequest,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_admin_user),
|
||
) -> dict[str, Any]:
|
||
"""批量导入工具。created_by 由服务端以 current_user.uid 填充。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = BatchImportToolsInput(
|
||
system_id=body.system_id,
|
||
tools=[ExternalToolCreateInput(**item.model_dump()) for item in body.tools],
|
||
created_by=current_user.uid,
|
||
)
|
||
output = await use_cases.tool_service.batch_import_tools(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.post("/import-from-wsdl", response_model=dict)
|
||
async def import_wsdl(
|
||
body: ImportWsdlRequest,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_admin_user),
|
||
) -> dict[str, Any]:
|
||
"""从 WSDL 导入工具。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = ImportWsdlInput(
|
||
wsdl_url=body.wsdl_url,
|
||
wsdl_content=body.wsdl_content,
|
||
system_id=body.system_id,
|
||
created_by=current_user.uid,
|
||
)
|
||
output = await use_cases.tool_service.import_wsdl(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.post("/execute", response_model=dict)
|
||
async def execute_external_tool(
|
||
body: ExecuteToolRequest,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""执行外部工具。caller 由服务端以 current_user.uid 填充。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = ExecuteToolInput(
|
||
tool_slug=body.tool_slug,
|
||
system_id=body.system_id,
|
||
env_key=body.env_key,
|
||
arguments=body.arguments,
|
||
caller=current_user.uid,
|
||
caller_id=body.caller_id,
|
||
correlation_id=body.correlation_id,
|
||
tags=body.tags,
|
||
)
|
||
output = await use_cases.tool_service.execute_external_tool(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.post("/{tool_slug}/health-check", response_model=dict)
|
||
async def health_check_external_tool(
|
||
tool_slug: str,
|
||
body: HealthCheckToolRequest | None = None,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""触发单个外部工具健康检查。
|
||
|
||
仅对 system_id 不为 None 的系统级工具持久化结果到 ``ext_system_health_checks``；
|
||
工具级工具仅返回探测结果。
|
||
"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = HealthCheckToolInput(
|
||
tool_slug=tool_slug,
|
||
env_key=body.env_key if body is not None else None,
|
||
)
|
||
output = await use_cases.tool_service.health_check_external_tool(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.post("/batch-execute", response_model=dict)
|
||
async def batch_execute_tools(
|
||
body: BatchExecuteToolsRequest,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""批量执行工具。caller 由服务端以 current_user.uid 填充。
|
||
|
||
单个执行项失败时不中断批量执行：执行器内部失败返回 ``status="failed"``，
|
||
前置校验失败（如工具不存在）抛出的异常由 service 层 try/except 捕获并记录错误。
|
||
"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = BatchExecuteToolsInput(
|
||
executions=[BatchExecuteToolItem(**item.model_dump()) for item in body.executions],
|
||
caller=current_user.uid,
|
||
)
|
||
output = await use_cases.tool_service.batch_execute_tools(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.post("/batch-clone", response_model=dict)
|
||
async def batch_clone_tools(
|
||
body: BatchCloneToolsRequest,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_admin_user),
|
||
) -> dict[str, Any]:
|
||
"""批量克隆工具。created_by 由服务端以 current_user.uid 填充。
|
||
|
||
单个事务内执行整个循环，单个失败时记录错误并继续
|
||
（参考 ``batch_import_tools`` 模式）。
|
||
"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = BatchCloneToolsInput(
|
||
source_tool_ids=body.source_tool_ids,
|
||
slug_suffix=body.slug_suffix,
|
||
override_config=body.override_config,
|
||
created_by=current_user.uid,
|
||
)
|
||
output = await use_cases.tool_service.batch_clone_tools(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
# =============================================================================
|
||
# === 根路径端点 ===
|
||
# =============================================================================
|
||
|
||
|
||
@tool_router.get("", response_model=dict)
|
||
async def list_tools(
|
||
limit: int = Query(100, ge=1, le=500),
|
||
offset: int = Query(0, ge=0),
|
||
system_id: int | None = Query(None),
|
||
category: str | None = Query(None),
|
||
adapter_type: str | None = Query(None),
|
||
enabled: bool | None = Query(None),
|
||
keyword: str | None = Query(None),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""分页列出外部工具。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = ListToolsInput(
|
||
page=offset // limit + 1,
|
||
page_size=limit,
|
||
system_id=system_id,
|
||
category=category,
|
||
adapter_type=adapter_type,
|
||
enabled=enabled,
|
||
keyword=keyword,
|
||
)
|
||
output = await use_cases.tool_service.list_tools(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.post("", response_model=dict)
|
||
async def create_tool(
|
||
body: CreateToolRequest,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_admin_user),
|
||
) -> dict[str, Any]:
|
||
"""创建外部工具。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = CreateToolInput(**body.model_dump(), created_by=current_user.uid)
|
||
output = await use_cases.tool_service.create_tool(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
# =============================================================================
|
||
# === 动态路径端点（/{tool_id} 与 /{tool_id}/versions） ===
|
||
# =============================================================================
|
||
|
||
|
||
@tool_router.get("/{tool_id}", response_model=dict)
|
||
async def get_tool(
|
||
tool_id: int,
|
||
system_id: int | None = Query(None),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""获取工具详情。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = GetToolInput(id=tool_id, system_id=system_id)
|
||
output = await use_cases.tool_service.get_tool(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.put("/{tool_id}", response_model=dict)
|
||
async def update_tool(
|
||
tool_id: int,
|
||
body: UpdateToolRequest,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_admin_user),
|
||
) -> dict[str, Any]:
|
||
"""更新外部工具。仅透传客户端显式设置的字段，保留部分更新语义。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = UpdateToolInput(
|
||
**body.model_dump(exclude_unset=True),
|
||
id=tool_id,
|
||
updated_by=current_user.uid,
|
||
)
|
||
output = await use_cases.tool_service.update_tool(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.delete("/{tool_id}", response_model=dict)
|
||
async def delete_tool(
|
||
tool_id: int,
|
||
system_id: int | None = Query(None),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_admin_user),
|
||
) -> dict[str, Any]:
|
||
"""删除外部工具。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = DeleteToolInput(id=tool_id, system_id=system_id, deleted_by=current_user.uid)
|
||
output = await use_cases.tool_service.delete_tool(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.post("/{tool_id}/clone", response_model=dict)
|
||
async def clone_tool(
|
||
tool_id: int,
|
||
body: CloneToolRequest,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_admin_user),
|
||
) -> dict[str, Any]:
|
||
"""克隆外部工具。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = CloneToolInput(
|
||
id=tool_id,
|
||
new_slug=body.new_slug,
|
||
new_name=body.new_name,
|
||
system_id=body.system_id,
|
||
created_by=current_user.uid,
|
||
)
|
||
output = await use_cases.tool_service.clone_tool(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.get("/{tool_id}/versions", response_model=dict)
|
||
async def get_tool_versions(
|
||
tool_id: int,
|
||
limit: int = Query(100, ge=1, le=500),
|
||
offset: int = Query(0, ge=0),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""获取工具版本列表。路径参数为 tool_id，service 层内部解析为 slug 查询。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = GetToolVersionsInput(
|
||
tool_id=tool_id,
|
||
page=offset // limit + 1,
|
||
page_size=limit,
|
||
)
|
||
output = await use_cases.tool_service.get_tool_versions(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
# -----------------------------------------------------------------------------
|
||
# === tool_router 扩展端点（动态路径） ===
|
||
# -----------------------------------------------------------------------------
|
||
|
||
|
||
@tool_router.get("/{tool_id}/versions/{version_id_1}/compare/{version_id_2}", response_model=dict)
|
||
async def compare_tool_versions(
|
||
tool_id: int,
|
||
version_id_1: str,
|
||
version_id_2: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""对比两个工具版本的参数差异。
|
||
|
||
snapshot 以明文存储，service 层使用 ``mask_all_string_values``
|
||
脱敏后对比结构差异，不泄露敏感信息。
|
||
"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = CompareToolVersionsInput(
|
||
tool_id=tool_id,
|
||
version_id_1=version_id_1,
|
||
version_id_2=version_id_2,
|
||
)
|
||
output = await use_cases.tool_service.compare_tool_versions(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.post("/{tool_id}/versions/{version_id}/rollback", response_model=dict)
|
||
async def rollback_tool_version(
|
||
tool_id: int,
|
||
version_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_admin_user),
|
||
) -> dict[str, Any]:
|
||
"""将工具回滚到指定历史版本。updated_by 由服务端以 current_user.uid 填充。
|
||
|
||
回滚前创建当前配置的新版本快照，记录回滚前的状态。
|
||
snapshot 以明文存储，service 层通过 persistence 层的
|
||
``get_decrypted_snapshot`` 方法获取明文后传给 ``ToolRepository.update``。
|
||
"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = RollbackToolVersionInput(
|
||
tool_id=tool_id,
|
||
version_id=version_id,
|
||
updated_by=current_user.uid,
|
||
)
|
||
output = await use_cases.tool_service.rollback_tool_version(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.get("/{tool_id}/parameter-template", response_model=dict)
|
||
async def get_tool_parameter_template(
|
||
tool_id: int,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""获取工具参数模板。
|
||
|
||
基于 ``AdapterMetadata.to_json_schema()`` + ``example_config`` 生成，
|
||
供前端动态表单渲染。
|
||
"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = GetToolParameterTemplateInput(tool_id=tool_id)
|
||
output = await use_cases.tool_service.get_tool_parameter_template(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.get("/{tool_id}/execution-trend", response_model=dict)
|
||
async def get_tool_execution_trend(
|
||
tool_id: int,
|
||
start_time: datetime | None = Query(None, description="开始时间（ISO 8601）"),
|
||
end_time: datetime | None = Query(None, description="结束时间（ISO 8601）"),
|
||
interval: Literal["hour", "day"] = Query("day", description="时间桶粒度（hour/day）"),
|
||
env_key: str | None = Query(None, description="环境 key 过滤"),
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""查询工具执行历史趋势（按天/小时聚合）。"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = GetToolExecutionTrendInput(
|
||
tool_id=tool_id,
|
||
start_time=start_time,
|
||
end_time=end_time,
|
||
interval=interval,
|
||
env_key=env_key,
|
||
)
|
||
output = await use_cases.tool_service.get_tool_execution_trend(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|
||
|
||
|
||
@tool_router.get("/{tool_id}/assets", response_model=dict)
|
||
async def get_tool_assets(
|
||
tool_id: int,
|
||
db: AsyncSession = Depends(get_db),
|
||
current_user: User = Depends(get_required_user),
|
||
) -> dict[str, Any]:
|
||
"""查询工具依赖的适配器资产。
|
||
|
||
工具与资产的关联关系通过 ``adapter_config`` 中的引用建立，
|
||
service 层按 checksum → asset_name → adapter_type 顺序解析。
|
||
"""
|
||
use_cases = create_use_cases_from_db(db)
|
||
input_dto = GetToolAssetsInput(tool_id=tool_id)
|
||
output = await use_cases.tool_service.get_tool_assets(input_dto)
|
||
return {"success": True, "data": output.model_dump()}
|