仓库模块完了

backend/app/routes/services.py

@@ -6,9 +6,10 @@ from pydantic import BaseModel
 import uuid
 import os
 
-from app.models.models import AlgorithmService
+from app.models.models import AlgorithmService, ServiceGroup, AlgorithmRepository
 from app.models.database import SessionLocal
 from app.routes.user import get_current_active_user
+from app.schemas.user import UserResponse
 from app.services.project_analyzer import ProjectAnalyzer
 from app.services.service_generator import ServiceGenerator
 from app.services.service_orchestrator import ServiceOrchestrator
@@ -83,6 +84,46 @@ class RepositoryAlgorithmsResponse(BaseModel):
     algorithms: List[Dict[str, Any]]
 
 
+class ServiceGroupRequest(BaseModel):
+    """服务分组请求"""
+    name: str
+    description: str = ""
+
+
+class ServiceGroupResponse(BaseModel):
+    """服务分组响应"""
+    id: str
+    name: str
+    description: str
+    status: str
+    created_at: str
+    updated_at: str
+
+
+class ServiceGroupListResponse(BaseModel):
+    """服务分组列表响应"""
+    success: bool
+    groups: List[ServiceGroupResponse]
+
+
+class ServiceGroupDetailResponse(BaseModel):
+    """服务分组详情响应"""
+    success: bool
+    group: ServiceGroupResponse
+
+
+class BatchOperationRequest(BaseModel):
+    """批量操作请求"""
+    service_ids: List[str]
+
+
+class BatchOperationResponse(BaseModel):
+    """批量操作响应"""
+    success: bool
+    message: str
+    results: List[Dict[str, Any]]
+
+
 # 初始化服务组件
 project_analyzer = ProjectAnalyzer()
 service_generator = ServiceGenerator()
@@ -92,19 +133,23 @@ service_orchestrator = ServiceOrchestrator()
 @router.post("/register", status_code=status.HTTP_201_CREATED)
 async def register_service(
     request: RegisterServiceRequest,
-    current_user: dict = Depends(get_current_active_user)
+    current_user: UserResponse = Depends(get_current_active_user)
 ):
     """注册新服务"""
     # 检查用户权限
-    if current_user.role != "admin":
+    if current_user.role_name != "admin":
         raise HTTPException(status_code=403, detail="Insufficient permissions")
     
     # 创建数据库会话
     db = SessionLocal()
     try:
         # 1. 获取仓库信息
-        # 注意：在实际实现中，应该从数据库中获取仓库信息
-        # 这里简化处理，假设仓库存在
+        repo = db.query(AlgorithmRepository).filter(AlgorithmRepository.id == request.repository_id).first()
+        if not repo:
+            raise HTTPException(status_code=404, detail="仓库不存在")
+        
+        # 记录仓库信息
+        print(f"仓库信息: {repo.name}, {repo.description}, {repo.repo_url}")
         
         # 2. 分析项目
         repo_path = f"/tmp/repository_{request.repository_id}"
@@ -157,7 +202,7 @@ def main(data):
             id=str(uuid.uuid4()),
             service_id=service_id,
             name=request.name,
-            algorithm_name="algorithm",  # 注意：在实际实现中，应该从仓库信息中获取
+            algorithm_name=repo.name,  # 使用仓库名称作为算法名称
             version=request.version,
             host=request.host,
             port=request.port,
@@ -200,11 +245,11 @@ def main(data):
 
 @router.get("", response_model=ServiceListResponse)
 async def list_services(
-    current_user: dict = Depends(get_current_active_user)
+    current_user: UserResponse = Depends(get_current_active_user)
 ):
     """获取服务列表"""
     # 检查用户权限
-    if current_user.role != "admin":
+    if current_user.role_name != "admin":
         raise HTTPException(status_code=403, detail="Insufficient permissions")
     
     # 创建数据库会话
@@ -241,11 +286,11 @@ async def list_services(
 @router.get("/{service_id}", response_model=ServiceDetailResponse)
 async def get_service(
     service_id: str,
-    current_user: dict = Depends(get_current_active_user)
+    current_user: UserResponse = Depends(get_current_active_user)
 ):
     """获取服务详情"""
     # 检查用户权限
-    if current_user.role != "admin":
+    if current_user.role_name != "admin":
         raise HTTPException(status_code=403, detail="Insufficient permissions")
     
     # 创建数据库会话
@@ -281,11 +326,11 @@ async def get_service(
 @router.post("/{service_id}/start")
 async def start_service(
     service_id: str,
-    current_user: dict = Depends(get_current_active_user)
+    current_user: UserResponse = Depends(get_current_active_user)
 ):
     """启动服务"""
     # 检查用户权限
-    if current_user.role != "admin":
+    if current_user.role_name != "admin":
         raise HTTPException(status_code=403, detail="Insufficient permissions")
     
     # 创建数据库会话
@@ -325,11 +370,11 @@ async def start_service(
 @router.post("/{service_id}/stop")
 async def stop_service(
     service_id: str,
-    current_user: dict = Depends(get_current_active_user)
+    current_user: UserResponse = Depends(get_current_active_user)
 ):
     """停止服务"""
     # 检查用户权限
-    if current_user.role != "admin":
+    if current_user.role_name != "admin":
         raise HTTPException(status_code=403, detail="Insufficient permissions")
     
     # 创建数据库会话
@@ -369,11 +414,11 @@ async def stop_service(
 @router.post("/{service_id}/restart")
 async def restart_service(
     service_id: str,
-    current_user: dict = Depends(get_current_active_user)
+    current_user: UserResponse = Depends(get_current_active_user)
 ):
     """重启服务"""
     # 检查用户权限
-    if current_user.role != "admin":
+    if current_user.role_name != "admin":
         raise HTTPException(status_code=403, detail="Insufficient permissions")
     
     # 创建数据库会话
@@ -413,11 +458,11 @@ async def restart_service(
 @router.delete("/{service_id}")
 async def delete_service(
     service_id: str,
-    current_user: dict = Depends(get_current_active_user)
+    current_user: UserResponse = Depends(get_current_active_user)
 ):
     """删除服务"""
     # 检查用户权限
-    if current_user.role != "admin":
+    if current_user.role_name != "admin":
         raise HTTPException(status_code=403, detail="Insufficient permissions")
     
     # 创建数据库会话
@@ -456,11 +501,11 @@ async def delete_service(
 @router.get("/{service_id}/status")
 async def get_service_status(
     service_id: str,
-    current_user: dict = Depends(get_current_active_user)
+    current_user: UserResponse = Depends(get_current_active_user)
 ):
     """获取服务状态"""
     # 检查用户权限
-    if current_user.role != "admin":
+    if current_user.role_name != "admin":
         raise HTTPException(status_code=403, detail="Insufficient permissions")
     
     # 创建数据库会话
@@ -496,11 +541,11 @@ async def get_service_status(
 async def get_service_logs(
     service_id: str,
     lines: int = 100,
-    current_user: dict = Depends(get_current_active_user)
+    current_user: UserResponse = Depends(get_current_active_user)
 ):
     """获取服务日志"""
     # 检查用户权限
-    if current_user.role != "admin":
+    if current_user.role_name != "admin":
         raise HTTPException(status_code=403, detail="Insufficient permissions")
     
     # 创建数据库会话
@@ -534,11 +579,11 @@ async def get_service_logs(
 @router.get("/repository/algorithms")
 async def get_repository_algorithms(
     repository_id: str,
-    current_user: dict = Depends(get_current_active_user)
+    current_user: UserResponse = Depends(get_current_active_user)
 ):
     """获取仓库中的算法列表"""
     # 检查用户权限
-    if current_user.role != "admin":
+    if current_user.role_name != "admin":
         raise HTTPException(status_code=403, detail="Insufficient permissions")
     
     try:
@@ -567,3 +612,453 @@ async def get_repository_algorithms(
         )
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
+
+
+# 服务分组管理API
+
+@router.post("/groups", status_code=status.HTTP_201_CREATED)
+async def create_service_group(
+    request: ServiceGroupRequest,
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """创建服务分组"""
+    # 检查用户权限
+    if current_user.role_name != "admin":
+        raise HTTPException(status_code=403, detail="Insufficient permissions")
+    
+    # 创建数据库会话
+    db = SessionLocal()
+    try:
+        # 生成唯一ID
+        group_id = str(uuid.uuid4())
+        
+        # 创建分组实例
+        group = ServiceGroup(
+            id=group_id,
+            name=request.name,
+            description=request.description
+        )
+        
+        # 保存到数据库
+        db.add(group)
+        db.commit()
+        db.refresh(group)
+        
+        return {
+            "success": True,
+            "message": "服务分组创建成功",
+            "group": {
+                "id": group.id,
+                "name": group.name,
+                "description": group.description,
+                "status": group.status,
+                "created_at": group.created_at.isoformat(),
+                "updated_at": group.updated_at.isoformat()
+            }
+        }
+    finally:
+        db.close()
+
+
+@router.get("/groups", response_model=ServiceGroupListResponse)
+async def list_service_groups(
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """获取服务分组列表"""
+    # 检查用户权限
+    if current_user.role_name != "admin":
+        raise HTTPException(status_code=403, detail="Insufficient permissions")
+    
+    # 创建数据库会话
+    db = SessionLocal()
+    try:
+        # 查询分组列表
+        groups = db.query(ServiceGroup).all()
+        
+        # 转换为响应格式
+        group_list = []
+        for group in groups:
+            group_list.append(ServiceGroupResponse(
+                id=group.id,
+                name=group.name,
+                description=group.description,
+                status=group.status,
+                created_at=group.created_at.isoformat(),
+                updated_at=group.updated_at.isoformat()
+            ))
+        
+        return ServiceGroupListResponse(
+            success=True,
+            groups=group_list
+        )
+    finally:
+        db.close()
+
+
+@router.get("/groups/{group_id}", response_model=ServiceGroupDetailResponse)
+async def get_service_group(
+    group_id: str,
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """获取服务分组详情"""
+    # 检查用户权限
+    if current_user.role_name != "admin":
+        raise HTTPException(status_code=403, detail="Insufficient permissions")
+    
+    # 创建数据库会话
+    db = SessionLocal()
+    try:
+        # 查询分组
+        group = db.query(ServiceGroup).filter(ServiceGroup.id == group_id).first()
+        
+        if not group:
+            raise HTTPException(status_code=404, detail="Service group not found")
+        
+        return ServiceGroupDetailResponse(
+            success=True,
+            group=ServiceGroupResponse(
+                id=group.id,
+                name=group.name,
+                description=group.description,
+                status=group.status,
+                created_at=group.created_at.isoformat(),
+                updated_at=group.updated_at.isoformat()
+            )
+        )
+    finally:
+        db.close()
+
+
+@router.put("/groups/{group_id}")
+async def update_service_group(
+    group_id: str,
+    request: ServiceGroupRequest,
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """更新服务分组"""
+    # 检查用户权限
+    if current_user.role_name != "admin":
+        raise HTTPException(status_code=403, detail="Insufficient permissions")
+    
+    # 创建数据库会话
+    db = SessionLocal()
+    try:
+        # 查询分组
+        group = db.query(ServiceGroup).filter(ServiceGroup.id == group_id).first()
+        
+        if not group:
+            raise HTTPException(status_code=404, detail="Service group not found")
+        
+        # 更新分组信息
+        group.name = request.name
+        group.description = request.description
+        
+        # 保存到数据库
+        db.commit()
+        db.refresh(group)
+        
+        return {
+            "success": True,
+            "message": "服务分组更新成功",
+            "group": {
+                "id": group.id,
+                "name": group.name,
+                "description": group.description,
+                "status": group.status,
+                "created_at": group.created_at.isoformat(),
+                "updated_at": group.updated_at.isoformat()
+            }
+        }
+    finally:
+        db.close()
+
+
+@router.delete("/groups/{group_id}")
+async def delete_service_group(
+    group_id: str,
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """删除服务分组"""
+    # 检查用户权限
+    if current_user.role_name != "admin":
+        raise HTTPException(status_code=403, detail="Insufficient permissions")
+    
+    # 创建数据库会话
+    db = SessionLocal()
+    try:
+        # 查询分组
+        group = db.query(ServiceGroup).filter(ServiceGroup.id == group_id).first()
+        
+        if not group:
+            raise HTTPException(status_code=404, detail="Service group not found")
+        
+        # 检查分组是否有服务
+        services_count = db.query(AlgorithmService).filter(AlgorithmService.group_id == group_id).count()
+        if services_count > 0:
+            raise HTTPException(status_code=400, detail=f"该分组下还有{services_count}个服务，无法删除")
+        
+        # 删除分组
+        db.delete(group)
+        db.commit()
+        
+        return {
+            "success": True,
+            "message": "服务分组删除成功",
+            "group_id": group_id
+        }
+    finally:
+        db.close()
+
+
+# 批量服务操作API
+
+@router.post("/batch/start")
+async def batch_start_services(
+    request: BatchOperationRequest,
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """批量启动服务"""
+    # 检查用户权限
+    if current_user.role_name != "admin":
+        raise HTTPException(status_code=403, detail="Insufficient permissions")
+    
+    # 创建数据库会话
+    db = SessionLocal()
+    try:
+        results = []
+        success_count = 0
+        
+        for service_id in request.service_ids:
+            # 查询服务
+            service = db.query(AlgorithmService).filter(AlgorithmService.service_id == service_id).first()
+            
+            if not service:
+                results.append({
+                    "service_id": service_id,
+                    "success": False,
+                    "message": "服务不存在"
+                })
+                continue
+            
+            # 获取容器ID
+            container_id = service.config.get("container_id")
+            if not container_id:
+                results.append({
+                    "service_id": service_id,
+                    "success": False,
+                    "message": "容器ID不存在"
+                })
+                continue
+            
+            # 启动服务
+            start_result = service_orchestrator.start_service(service_id, container_id)
+            if start_result["success"]:
+                # 更新服务状态
+                service.status = start_result["status"]
+                db.commit()
+                success_count += 1
+                results.append({
+                    "service_id": service_id,
+                    "success": True,
+                    "message": "服务启动成功"
+                })
+            else:
+                results.append({
+                    "service_id": service_id,
+                    "success": False,
+                    "message": f"服务启动失败: {start_result['error']}"
+                })
+        
+        return BatchOperationResponse(
+            success=True,
+            message=f"批量启动完成，成功{success_count}个，失败{len(request.service_ids) - success_count}个",
+            results=results
+        )
+    finally:
+        db.close()
+
+
+@router.post("/batch/stop")
+async def batch_stop_services(
+    request: BatchOperationRequest,
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """批量停止服务"""
+    # 检查用户权限
+    if current_user.role_name != "admin":
+        raise HTTPException(status_code=403, detail="Insufficient permissions")
+    
+    # 创建数据库会话
+    db = SessionLocal()
+    try:
+        results = []
+        success_count = 0
+        
+        for service_id in request.service_ids:
+            # 查询服务
+            service = db.query(AlgorithmService).filter(AlgorithmService.service_id == service_id).first()
+            
+            if not service:
+                results.append({
+                    "service_id": service_id,
+                    "success": False,
+                    "message": "服务不存在"
+                })
+                continue
+            
+            # 获取容器ID
+            container_id = service.config.get("container_id")
+            if not container_id:
+                results.append({
+                    "service_id": service_id,
+                    "success": False,
+                    "message": "容器ID不存在"
+                })
+                continue
+            
+            # 停止服务
+            stop_result = service_orchestrator.stop_service(service_id, container_id)
+            if stop_result["success"]:
+                # 更新服务状态
+                service.status = stop_result["status"]
+                db.commit()
+                success_count += 1
+                results.append({
+                    "service_id": service_id,
+                    "success": True,
+                    "message": "服务停止成功"
+                })
+            else:
+                results.append({
+                    "service_id": service_id,
+                    "success": False,
+                    "message": f"服务停止失败: {stop_result['error']}"
+                })
+        
+        return BatchOperationResponse(
+            success=True,
+            message=f"批量停止完成，成功{success_count}个，失败{len(request.service_ids) - success_count}个",
+            results=results
+        )
+    finally:
+        db.close()
+
+
+@router.post("/batch/restart")
+async def batch_restart_services(
+    request: BatchOperationRequest,
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """批量重启服务"""
+    # 检查用户权限
+    if current_user.role_name != "admin":
+        raise HTTPException(status_code=403, detail="Insufficient permissions")
+    
+    # 创建数据库会话
+    db = SessionLocal()
+    try:
+        results = []
+        success_count = 0
+        
+        for service_id in request.service_ids:
+            # 查询服务
+            service = db.query(AlgorithmService).filter(AlgorithmService.service_id == service_id).first()
+            
+            if not service:
+                results.append({
+                    "service_id": service_id,
+                    "success": False,
+                    "message": "服务不存在"
+                })
+                continue
+            
+            # 获取容器ID
+            container_id = service.config.get("container_id")
+            if not container_id:
+                results.append({
+                    "service_id": service_id,
+                    "success": False,
+                    "message": "容器ID不存在"
+                })
+                continue
+            
+            # 重启服务
+            restart_result = service_orchestrator.restart_service(service_id, container_id)
+            if restart_result["success"]:
+                # 更新服务状态
+                service.status = restart_result["status"]
+                db.commit()
+                success_count += 1
+                results.append({
+                    "service_id": service_id,
+                    "success": True,
+                    "message": "服务重启成功"
+                })
+            else:
+                results.append({
+                    "service_id": service_id,
+                    "success": False,
+                    "message": f"服务重启失败: {restart_result['error']}"
+                })
+        
+        return BatchOperationResponse(
+            success=True,
+            message=f"批量重启完成，成功{success_count}个，失败{len(request.service_ids) - success_count}个",
+            results=results
+        )
+    finally:
+        db.close()
+
+
+@router.post("/batch/delete")
+async def batch_delete_services(
+    request: BatchOperationRequest,
+    current_user: UserResponse = Depends(get_current_active_user)
+):
+    """批量删除服务"""
+    # 检查用户权限
+    if current_user.role_name != "admin":
+        raise HTTPException(status_code=403, detail="Insufficient permissions")
+    
+    # 创建数据库会话
+    db = SessionLocal()
+    try:
+        results = []
+        success_count = 0
+        
+        for service_id in request.service_ids:
+            # 查询服务
+            service = db.query(AlgorithmService).filter(AlgorithmService.service_id == service_id).first()
+            
+            if not service:
+                results.append({
+                    "service_id": service_id,
+                    "success": False,
+                    "message": "服务不存在"
+                })
+                continue
+            
+            # 获取容器ID和镜像名称
+            container_id = service.config.get("container_id")
+            image_name = f"algorithm-service-{service_id}:{service.version}"
+            
+            # 删除服务
+            delete_result = service_orchestrator.delete_service(service_id, container_id, image_name)
+            
+            # 删除数据库记录
+            db.delete(service)
+            db.commit()
+            success_count += 1
+            results.append({
+                "service_id": service_id,
+                "success": True,
+                "message": "服务删除成功"
+            })
+        
+        return BatchOperationResponse(
+            success=True,
+            message=f"批量删除完成，成功{success_count}个，失败{len(request.service_ids) - success_count}个",
+            results=results
+        )
+    finally:
+        db.close()