good version for 算法注册

backend/app/routes/api_management.py

@@ -0,0 +1,510 @@
+"""API管理路由，处理API端点的封装和管理"""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+from sqlalchemy.orm import Session
+import logging
+from datetime import datetime
+
+from app.models.database import get_db
+from app.models.models import Algorithm, AlgorithmVersion, AlgorithmService, User
+from app.models.api import ApiEndpoint, ApiCallLog
+from app.schemas.user import UserResponse
+from app.routes.user import get_current_active_user
+
+router = APIRouter(prefix="/api-management", tags=["api-management"])
+
+logger = logging.getLogger(__name__)
+
+
+class ApiEndpointCreate(BaseModel):
+    """创建API端点请求模型"""
+    name: str
+    description: str = ""
+    path: str
+    method: str = "POST"
+    algorithm_id: str
+    version_id: str
+    service_id: Optional[str] = None
+    requires_auth: bool = True
+    allowed_roles: List[str] = []
+    rate_limit: Optional[Dict[str, Any]] = None
+    is_public: bool = False
+    config: Dict[str, Any] = {}
+
+
+class ApiEndpointUpdate(BaseModel):
+    """更新API端点请求模型"""
+    name: Optional[str] = None
+    description: Optional[str] = None
+    path: Optional[str] = None
+    method: Optional[str] = None
+    requires_auth: Optional[bool] = None
+    allowed_roles: Optional[List[str]] = None
+    rate_limit: Optional[Dict[str, Any]] = None
+    is_public: Optional[bool] = None
+    config: Optional[Dict[str, Any]] = None
+    status: Optional[str] = None
+
+
+class ApiEndpointResponse(BaseModel):
+    """API端点响应模型"""
+    id: str
+    name: str
+    description: str
+    path: str
+    method: str
+    algorithm_id: str
+    algorithm_name: str
+    version_id: str
+    version: str
+    service_id: Optional[str]
+    status: str
+    is_public: bool
+    call_count: str
+    success_count: str
+    error_count: str
+    avg_response_time: str
+    created_at: datetime
+    updated_at: Optional[datetime]
+    last_called_at: Optional[datetime]
+
+
+class ApiEndpointListResponse(BaseModel):
+    """API端点列表响应模型"""
+    endpoints: List[ApiEndpointResponse]
+    total: int
+
+
+class ApiStatsResponse(BaseModel):
+    """API统计响应模型"""
+    total_endpoints: int
+    active_endpoints: int
+    total_calls: str
+    total_success: str
+    total_errors: str
+    avg_response_time: str
+
+
+@router.get("/endpoints", response_model=ApiEndpointListResponse)
+async def get_api_endpoints(
+    skip: int = 0,
+    limit: int = 100,
+    algorithm_id: Optional[str] = None,
+    status: Optional[str] = None,
+    db: Session = Depends(get_db),
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """获取API端点列表"""
+    try:
+        # 构建查询
+        query = db.query(ApiEndpoint)
+        
+        # 筛选条件
+        if algorithm_id:
+            query = query.filter(ApiEndpoint.algorithm_id == algorithm_id)
+        if status:
+            query = query.filter(ApiEndpoint.status == status)
+        
+        # 分页
+        endpoints = query.offset(skip).limit(limit).all()
+        total = query.count()
+        
+        # 构建响应
+        endpoint_responses = []
+        for endpoint in endpoints:
+            # 获取关联的算法和版本信息
+            algorithm = db.query(Algorithm).filter(Algorithm.id == endpoint.algorithm_id).first()
+            version = db.query(AlgorithmVersion).filter(AlgorithmVersion.id == endpoint.version_id).first()
+            
+            endpoint_responses.append({
+                "id": endpoint.id,
+                "name": endpoint.name,
+                "description": endpoint.description,
+                "path": endpoint.path,
+                "method": endpoint.method,
+                "algorithm_id": endpoint.algorithm_id,
+                "algorithm_name": algorithm.name if algorithm else "",
+                "version_id": endpoint.version_id,
+                "version": version.version if version else "",
+                "service_id": endpoint.service_id,
+                "status": endpoint.status,
+                "is_public": endpoint.is_public,
+                "call_count": endpoint.call_count,
+                "success_count": endpoint.success_count,
+                "error_count": endpoint.error_count,
+                "avg_response_time": endpoint.avg_response_time,
+                "created_at": endpoint.created_at,
+                "updated_at": endpoint.updated_at,
+                "last_called_at": endpoint.last_called_at
+            })
+        
+        return {
+            "endpoints": endpoint_responses,
+            "total": total
+        }
+    except Exception as e:
+        logger.error(f"获取API端点列表失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"获取API端点列表失败: {str(e)}")
+
+
+@router.get("/endpoints/{endpoint_id}", response_model=ApiEndpointResponse)
+async def get_api_endpoint(
+    endpoint_id: str,
+    db: Session = Depends(get_db),
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """获取API端点详情"""
+    try:
+        endpoint = db.query(ApiEndpoint).filter(ApiEndpoint.id == endpoint_id).first()
+        
+        if not endpoint:
+            raise HTTPException(status_code=404, detail="API端点不存在")
+        
+        # 获取关联的算法和版本信息
+        algorithm = db.query(Algorithm).filter(Algorithm.id == endpoint.algorithm_id).first()
+        version = db.query(AlgorithmVersion).filter(AlgorithmVersion.id == endpoint.version_id).first()
+        
+        return {
+            "id": endpoint.id,
+            "name": endpoint.name,
+            "description": endpoint.description,
+            "path": endpoint.path,
+            "method": endpoint.method,
+            "algorithm_id": endpoint.algorithm_id,
+            "algorithm_name": algorithm.name if algorithm else "",
+            "version_id": endpoint.version_id,
+            "version": version.version if version else "",
+            "service_id": endpoint.service_id,
+            "status": endpoint.status,
+            "is_public": endpoint.is_public,
+            "call_count": endpoint.call_count,
+            "success_count": endpoint.success_count,
+            "error_count": endpoint.error_count,
+            "avg_response_time": endpoint.avg_response_time,
+            "created_at": endpoint.created_at,
+            "updated_at": endpoint.updated_at,
+            "last_called_at": endpoint.last_called_at
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"获取API端点详情失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"获取API端点详情失败: {str(e)}")
+
+
+@router.post("/endpoints", response_model=ApiEndpointResponse, status_code=status.HTTP_201_CREATED)
+async def create_api_endpoint(
+    request: ApiEndpointCreate,
+    db: Session = Depends(get_db),
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """创建API端点"""
+    try:
+        # 检查用户权限
+        if not hasattr(current_user, 'role_name') or current_user.role_name != "admin":
+            raise HTTPException(status_code=403, detail="Insufficient permissions")
+        
+        # 验证算法和版本是否存在
+        algorithm = db.query(Algorithm).filter(Algorithm.id == request.algorithm_id).first()
+        if not algorithm:
+            raise HTTPException(status_code=404, detail="算法不存在")
+        
+        version = db.query(AlgorithmVersion).filter(
+            AlgorithmVersion.id == request.version_id
+        ).first()
+        if not version or version.algorithm_id != request.algorithm_id:
+            raise HTTPException(status_code=404, detail="算法版本不存在")
+        
+        # 如果指定了服务ID，验证服务是否存在
+        if request.service_id:
+            service = db.query(AlgorithmService).filter(
+                AlgorithmService.service_id == request.service_id
+            ).first()
+            if not service:
+                raise HTTPException(status_code=404, detail="服务不存在")
+        
+        # 检查API路径是否已存在
+        existing_endpoint = db.query(ApiEndpoint).filter(
+            ApiEndpoint.path == request.path
+        ).first()
+        if existing_endpoint:
+            raise HTTPException(status_code=400, detail="API路径已存在")
+        
+        # 创建API端点
+        new_endpoint = ApiEndpoint(
+            name=request.name,
+            description=request.description,
+            path=request.path,
+            method=request.method,
+            algorithm_id=request.algorithm_id,
+            version_id=request.version_id,
+            service_id=request.service_id,
+            requires_auth=request.requires_auth,
+            allowed_roles=request.allowed_roles,
+            rate_limit=request.rate_limit,
+            is_public=request.is_public,
+            config=request.config,
+            status="active",
+            call_count="0",
+            success_count="0",
+            error_count="0",
+            avg_response_time="0.0"
+        )
+        
+        db.add(new_endpoint)
+        db.commit()
+        db.refresh(new_endpoint)
+        
+        # 返回创建的API端点
+        return {
+            "id": new_endpoint.id,
+            "name": new_endpoint.name,
+            "description": new_endpoint.description,
+            "path": new_endpoint.path,
+            "method": new_endpoint.method,
+            "algorithm_id": new_endpoint.algorithm_id,
+            "algorithm_name": algorithm.name,
+            "version_id": new_endpoint.version_id,
+            "version": version.version,
+            "service_id": new_endpoint.service_id,
+            "status": new_endpoint.status,
+            "is_public": new_endpoint.is_public,
+            "call_count": new_endpoint.call_count,
+            "success_count": new_endpoint.success_count,
+            "error_count": new_endpoint.error_count,
+            "avg_response_time": new_endpoint.avg_response_time,
+            "created_at": new_endpoint.created_at,
+            "updated_at": new_endpoint.updated_at,
+            "last_called_at": new_endpoint.last_called_at
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"创建API端点失败: {str(e)}")
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"创建API端点失败: {str(e)}")
+
+
+@router.put("/endpoints/{endpoint_id}", response_model=ApiEndpointResponse)
+async def update_api_endpoint(
+    endpoint_id: str,
+    request: ApiEndpointUpdate,
+    db: Session = Depends(get_db),
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """更新API端点"""
+    try:
+        # 检查用户权限
+        if not hasattr(current_user, 'role_name') or current_user.role_name != "admin":
+            raise HTTPException(status_code=403, detail="Insufficient permissions")
+        
+        # 查询API端点
+        endpoint = db.query(ApiEndpoint).filter(ApiEndpoint.id == endpoint_id).first()
+        if not endpoint:
+            raise HTTPException(status_code=404, detail="API端点不存在")
+        
+        # 更新字段
+        if request.name is not None:
+            endpoint.name = request.name
+        if request.description is not None:
+            endpoint.description = request.description
+        if request.path is not None:
+            # 检查新路径是否已被其他端点使用
+            existing_endpoint = db.query(ApiEndpoint).filter(
+                ApiEndpoint.path == request.path,
+                ApiEndpoint.id != endpoint_id
+            ).first()
+            if existing_endpoint:
+                raise HTTPException(status_code=400, detail="API路径已存在")
+            endpoint.path = request.path
+        if request.method is not None:
+            endpoint.method = request.method
+        if request.requires_auth is not None:
+            endpoint.requires_auth = request.requires_auth
+        if request.allowed_roles is not None:
+            endpoint.allowed_roles = request.allowed_roles
+        if request.rate_limit is not None:
+            endpoint.rate_limit = request.rate_limit
+        if request.is_public is not None:
+            endpoint.is_public = request.is_public
+        if request.config is not None:
+            endpoint.config = request.config
+        if request.status is not None:
+            endpoint.status = request.status
+        
+        db.commit()
+        db.refresh(endpoint)
+        
+        # 获取关联的算法和版本信息
+        algorithm = db.query(Algorithm).filter(Algorithm.id == endpoint.algorithm_id).first()
+        version = db.query(AlgorithmVersion).filter(AlgorithmVersion.id == endpoint.version_id).first()
+        
+        return {
+            "id": endpoint.id,
+            "name": endpoint.name,
+            "description": endpoint.description,
+            "path": endpoint.path,
+            "method": endpoint.method,
+            "algorithm_id": endpoint.algorithm_id,
+            "algorithm_name": algorithm.name if algorithm else "",
+            "version_id": endpoint.version_id,
+            "version": version.version if version else "",
+            "service_id": endpoint.service_id,
+            "status": endpoint.status,
+            "is_public": endpoint.is_public,
+            "call_count": endpoint.call_count,
+            "success_count": endpoint.success_count,
+            "error_count": endpoint.error_count,
+            "avg_response_time": endpoint.avg_response_time,
+            "created_at": endpoint.created_at,
+            "updated_at": endpoint.updated_at,
+            "last_called_at": endpoint.last_called_at
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"更新API端点失败: {str(e)}")
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"更新API端点失败: {str(e)}")
+
+
+@router.delete("/endpoints/{endpoint_id}")
+async def delete_api_endpoint(
+    endpoint_id: str,
+    db: Session = Depends(get_db),
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """删除API端点"""
+    try:
+        # 检查用户权限
+        if not hasattr(current_user, 'role_name') or current_user.role_name != "admin":
+            raise HTTPException(status_code=403, detail="Insufficient permissions")
+        
+        # 查询API端点
+        endpoint = db.query(ApiEndpoint).filter(ApiEndpoint.id == endpoint_id).first()
+        if not endpoint:
+            raise HTTPException(status_code=404, detail="API端点不存在")
+        
+        # 删除API端点
+        db.delete(endpoint)
+        db.commit()
+        
+        return {
+            "success": True,
+            "message": "API端点删除成功"
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"删除API端点失败: {str(e)}")
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"删除API端点失败: {str(e)}")
+
+
+@router.get("/stats", response_model=ApiStatsResponse)
+async def get_api_stats(
+    db: Session = Depends(get_db),
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """获取API统计信息"""
+    try:
+        # 检查用户权限
+        if not hasattr(current_user, 'role_name') or current_user.role_name != "admin":
+            raise HTTPException(status_code=403, detail="Insufficient permissions")
+        
+        # 统计API端点
+        total_endpoints = db.query(ApiEndpoint).count()
+        active_endpoints = db.query(ApiEndpoint).filter(ApiEndpoint.status == "active").count()
+        
+        # 统计调用次数
+        endpoints = db.query(ApiEndpoint).all()
+        total_calls = sum(int(e.call_count or 0) for e in endpoints)
+        total_success = sum(int(e.success_count or 0) for e in endpoints)
+        total_errors = sum(int(e.error_count or 0) for e in endpoints)
+        
+        # 计算平均响应时间
+        avg_response_times = [float(e.avg_response_time or 0) for e in endpoints if float(e.avg_response_time or 0) > 0]
+        avg_response_time = sum(avg_response_times) / len(avg_response_times) if avg_response_times else 0.0
+        
+        return {
+            "total_endpoints": total_endpoints,
+            "active_endpoints": active_endpoints,
+            "total_calls": str(total_calls),
+            "total_success": str(total_success),
+            "total_errors": str(total_errors),
+            "avg_response_time": f"{avg_response_time:.2f}"
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"获取API统计信息失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"获取API统计信息失败: {str(e)}")
+
+
+@router.post("/endpoints/{endpoint_id}/test")
+async def test_api_endpoint(
+    endpoint_id: str,
+    payload: Dict[str, Any],
+    db: Session = Depends(get_db),
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """测试API端点"""
+    try:
+        # 查询API端点
+        endpoint = db.query(ApiEndpoint).filter(ApiEndpoint.id == endpoint_id).first()
+        if not endpoint:
+            raise HTTPException(status_code=404, detail="API端点不存在")
+        
+        # 检查API端点状态
+        if endpoint.status != "active":
+            raise HTTPException(status_code=400, detail="API端点未激活")
+        
+        # 查询关联的服务
+        if endpoint.service_id:
+            service = db.query(AlgorithmService).filter(
+                AlgorithmService.service_id == endpoint.service_id
+            ).first()
+            if not service or service.status != "running":
+                raise HTTPException(status_code=400, detail="关联服务未运行")
+            
+            # 调用服务
+            import httpx
+            import time
+            
+            service_url = service.api_url
+            if not service_url.endswith("/"):
+                service_url += "/"
+            
+            call_url = f"{service_url}predict"
+            
+            start_time = time.time()
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.post(
+                    call_url,
+                    json=payload,
+                    headers={"Content-Type": "application/json"}
+                )
+                response_time = time.time() - start_time
+                
+                if response.status_code == 200:
+                    return {
+                        "success": True,
+                        "result": response.json(),
+                        "response_time": response_time,
+                        "message": "API调用成功"
+                    }
+                else:
+                    return {
+                        "success": False,
+                        "error": f"服务返回错误: HTTP {response.status_code}",
+                        "response_time": response_time
+                    }
+        else:
+            raise HTTPException(status_code=400, detail="API端点未关联服务")
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"测试API端点失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"测试API端点失败: {str(e)}")