feat(backend): 更新 API 端点实现

- 更新 Chunks API 端点
- 更新 Datasets API 端点
- 更新 Evaluation API 端点
- 更新 Files API 端点
- 更新 Projects API 端点
- 更新 Questions API 端点

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

backend/app/api/v1/projects/__init__.py

@@ -1,74 +1,111 @@
 """
 Projects API Router
 """
-from typing import List
+import logging
+from typing import List, Optional
 from uuid import UUID
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, Query
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select
+
+from app.api.response import ApiResponse, PaginatedResponse
 from app.core.database import get_db
+from app.core.exceptions import NotFoundException
+from app.core.crud import CRUDBase
 from app.models.models import Project
-from app.schemas.base import (
+from app.schemas.project import (
     ProjectCreate,
     ProjectUpdate,
-    ProjectResponse
+    ProjectResponse,
+    ProjectCreateSchema,
+    ProjectUpdateSchema
 )
 
 router = APIRouter()
+logger = logging.getLogger("yg_dataset.projects")
+
+# Initialize CRUD
+project_crud = CRUDBase(Project)
 
 
-@router.get("/", response_model=dict)
-async def list_projects(db: AsyncSession = Depends(get_db)):
-    """List all projects"""
-    result = await db.execute(select(Project).order_by(Project.created_at.desc()))
-    projects = result.scalars().all()
-    return {"projects": [ProjectResponse.model_validate(p) for p in projects]}
+@router.get("", response_model=ApiResponse)
+async def list_projects(
+    page: int = Query(1, ge=1, description="Page number"),
+    page_size: int = Query(20, ge=1, le=100, description="Page size"),
+    db: AsyncSession = Depends(get_db)
+):
+    """List all projects with pagination"""
+    logger.info(f"Listing projects - page: {page}, page_size: {page_size}")
+    skip = (page - 1) * page_size
+    projects, total = await project_crud.get_multi(
+        db,
+        skip=skip,
+        limit=page_size,
+        order_by="created_at",
+        descending=True
+    )
+
+    logger.info(f"Found {total} projects, returning {len(projects)} items")
+    project_responses = [ProjectResponse.model_validate(p) for p in projects]
+    return PaginatedResponse.ok(
+        items=project_responses,
+        page=page,
+        page_size=page_size,
+        total=total
+    )
 
 
-@router.post("/", response_model=dict)
-async def create_project(project: ProjectCreate, db: AsyncSession = Depends(get_db)):
+@router.post("", response_model=ApiResponse)
+async def create_project(
+    project: ProjectCreateSchema,
+    db: AsyncSession = Depends(get_db)
+):
     """Create a new project"""
-    db_project = Project(**project.model_dump())
-    db.add(db_project)
-    await db.commit()
-    await db.refresh(db_project)
-    return {"id": str(db_project.id)}
+    logger.info(f"Creating project: name={project.name}, description={project.description}")
+    db_project = await project_crud.create(db, project)
+    logger.info(f"Project created successfully: id={db_project.id}")
+    return ApiResponse.ok(
+        data={"id": str(db_project.id)},
+        message="Project created successfully"
+    )
 
 
-@router.get("/{project_id}", response_model=dict)
-async def get_project(project_id: UUID, db: AsyncSession = Depends(get_db)):
+@router.get("/{project_id}", response_model=ApiResponse)
+async def get_project(
+    project_id: UUID,
+    db: AsyncSession = Depends(get_db)
+):
     """Get project by ID"""
-    result = await db.execute(select(Project).where(Project.id == project_id))
-    project = result.scalar_one_or_none()
-    if not project:
-        raise HTTPException(status_code=404, detail="Project not found")
-    return ProjectResponse.model_validate(project)
+    logger.info(f"Getting project: id={project_id}")
+    project = await project_crud.get_or_raise(db, project_id, "Project")
+    logger.info(f"Found project: name={project.name}")
+    return ApiResponse.ok(data=ProjectResponse.model_validate(project))
 
 
-@router.put("/{project_id}", response_model=dict)
-async def update_project(project_id: UUID, project: ProjectUpdate, db: AsyncSession = Depends(get_db)):
+@router.put("/{project_id}", response_model=ApiResponse)
+async def update_project(
+    project_id: UUID,
+    project: ProjectUpdateSchema,
+    db: AsyncSession = Depends(get_db)
+):
     """Update project"""
-    result = await db.execute(select(Project).where(Project.id == project_id))
-    db_project = result.scalar_one_or_none()
-    if not db_project:
-        raise HTTPException(status_code=404, detail="Project not found")
-
-    for key, value in project.model_dump(exclude_unset=True).items():
-        setattr(db_project, key, value)
-
-    await db.commit()
-    await db.refresh(db_project)
-    return ProjectResponse.model_validate(db_project)
+    logger.info(f"Updating project: id={project_id}")
+    db_project = await project_crud.get_or_raise(db, project_id, "Project")
+    updated_project = await project_crud.update(db, db_project, project)
+    logger.info(f"Project updated: name={updated_project.name}")
+    return ApiResponse.ok(
+        data=ProjectResponse.model_validate(updated_project),
+        message="Project updated successfully"
+    )
 
 
-@router.delete("/{project_id}", response_model=dict)
-async def delete_project(project_id: UUID, db: AsyncSession = Depends(get_db)):
+@router.delete("/{project_id}", response_model=ApiResponse)
+async def delete_project(
+    project_id: UUID,
+    db: AsyncSession = Depends(get_db)
+):
     """Delete project"""
-    result = await db.execute(select(Project).where(Project.id == project_id))
-    project = result.scalar_one_or_none()
-    if not project:
-        raise HTTPException(status_code=404, detail="Project not found")
-
-    await db.delete(project)
-    await db.commit()
-    return {"message": "Project deleted successfully"}
+    logger.info(f"Deleting project: id={project_id}")
+    await project_crud.get_or_raise(db, project_id, "Project")
+    await project_crud.delete(db, project_id)
+    logger.info(f"Project deleted: id={project_id}")
+    return ApiResponse.ok(message="Project deleted successfully")