完善skills；测试用例生成页面功能初步实现

rag-web-ui/backend/app/api/api_v1/testing.py

@@ -1,6 +1,8 @@
+import logging
+import asyncio
 from typing import Any, Dict, List
 
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 
 from app.core.config import settings
@@ -15,6 +17,8 @@ from app.services.testing_pipeline import run_testing_pipeline
 from app.services.vector_store import VectorStoreFactory
 
 router = APIRouter()
+logger = logging.getLogger(__name__)
+MODEL_PIPELINE_TIMEOUT_SECONDS = 300
 
 
 async def _build_kb_vector_stores(db: Session, knowledge_bases: List[KnowledgeBase]) -> List[Dict[str, Any]]:
@@ -47,38 +51,75 @@ async def generate_testing_content(
 
     knowledge_context = (payload.knowledge_context or "").strip()
     if payload.knowledge_base_ids:
-        knowledge_bases = (
-            db.query(KnowledgeBase)
-            .filter(
-                KnowledgeBase.id.in_(payload.knowledge_base_ids),
-                KnowledgeBase.user_id == current_user.id,
+        try:
+            knowledge_bases = (
+                db.query(KnowledgeBase)
+                .filter(
+                    KnowledgeBase.id.in_(payload.knowledge_base_ids),
+                    KnowledgeBase.user_id == current_user.id,
+                )
+                .all()
             )
-            .all()
+
+            kb_vector_stores = await _build_kb_vector_stores(db, knowledge_bases)
+            if kb_vector_stores:
+                retriever = MultiKBRetriever(
+                    reranker_weight=settings.RERANKER_WEIGHT,
+                )
+                retrieval_rows = await retriever.retrieve(
+                    query=payload.requirement_text,
+                    kb_vector_stores=kb_vector_stores,
+                    fetch_k_per_kb=max(12, payload.retrieval_top_k * 2),
+                    top_k=payload.retrieval_top_k,
+                )
+                if retrieval_rows:
+                    knowledge_context = format_retrieval_context(retrieval_rows)
+        except Exception as exc:
+            logger.exception(
+                "Testing generation retrieval fallback triggered for user=%s knowledge_base_ids=%s: %s",
+                current_user.id,
+                payload.knowledge_base_ids,
+                exc,
+            )
+
+    pipeline_kwargs = {
+        "user_requirement_text": payload.requirement_text,
+        "requirement_type_input": payload.requirement_type,
+        "debug": payload.debug,
+        "knowledge_context": knowledge_context,
+        "use_model_generation": payload.use_model_generation,
+        "max_items_per_group": payload.max_items_per_group,
+        "cases_per_item": payload.cases_per_item,
+        "max_focus_points": payload.max_focus_points,
+        "max_llm_calls": payload.max_llm_calls,
+    }
+
+    try:
+        result = await asyncio.wait_for(
+            asyncio.to_thread(run_testing_pipeline, **pipeline_kwargs),
+            timeout=MODEL_PIPELINE_TIMEOUT_SECONDS,
         )
+    except asyncio.TimeoutError as exc:
+        logger.exception(
+            "Testing pipeline timed out for user=%s use_model_generation=%s after %s seconds",
+            current_user.id,
+            payload.use_model_generation,
+            MODEL_PIPELINE_TIMEOUT_SECONDS,
+        )
+        raise HTTPException(
+            status_code=504,
+            detail=f"LLM generation timed out after {MODEL_PIPELINE_TIMEOUT_SECONDS} seconds",
+        ) from exc
+    except Exception as exc:
+        logger.exception(
+            "Testing pipeline failed for user=%s use_model_generation=%s: %s",
+            current_user.id,
+            payload.use_model_generation,
+            exc,
+        )
+        raise HTTPException(
+            status_code=500,
+            detail=f"LLM generation failed: {exc}",
+        ) from exc
 
-        kb_vector_stores = await _build_kb_vector_stores(db, knowledge_bases)
-        if kb_vector_stores:
-            retriever = MultiKBRetriever(
-                reranker_weight=settings.RERANKER_WEIGHT,
-            )
-            retrieval_rows = await retriever.retrieve(
-                query=payload.requirement_text,
-                kb_vector_stores=kb_vector_stores,
-                fetch_k_per_kb=max(12, payload.retrieval_top_k * 2),
-                top_k=payload.retrieval_top_k,
-            )
-            if retrieval_rows:
-                knowledge_context = format_retrieval_context(retrieval_rows)
-
-    result = run_testing_pipeline(
-        user_requirement_text=payload.requirement_text,
-        requirement_type_input=payload.requirement_type,
-        debug=payload.debug,
-        knowledge_context=knowledge_context,
-        use_model_generation=payload.use_model_generation,
-        max_items_per_group=payload.max_items_per_group,
-        cases_per_item=payload.cases_per_item,
-        max_focus_points=payload.max_focus_points,
-        max_llm_calls=payload.max_llm_calls,
-    )
     return result

rag-web-ui/backend/app/api/api_v1/tools.py

@@ -1,26 +1,46 @@
 from pathlib import Path
 from typing import Any, List
 
+import shutil
+
 from fastapi import APIRouter, BackgroundTasks, Depends, File, HTTPException, UploadFile
 from sqlalchemy.orm import Session
 
 from app.core.security import get_current_user
 from app.db.session import get_db
-from app.models.tooling import SRSExtraction, ToolJob
+from app.models.knowledge import KnowledgeBase
+from app.models.tooling import SRSExtraction, TestingGeneration, ToolJob
 from app.models.user import User
 from app.schemas.tooling import (
     SRSToolCreateJobResponse,
+    SRSToolHistoryItem,
     SRSToolJobStatusResponse,
     SRSToolRequirementsSaveRequest,
     SRSToolResultResponse,
+    TestingGenerationCreateRequest,
+    TestingGenerationCreateResponse,
+    TestingGenerationHistoryItem,
+    TestingGenerationJobStatusResponse,
+    TestingGenerationResultResponse,
+    TestingGenerationSaveRequest,
     ToolDefinitionResponse,
 )
 from app.services.srs_job_service import (
+    build_srs_upload_path,
     build_result_response,
+    delete_srs_job,
     ensure_upload_path,
+    list_srs_history,
     replace_requirements,
     run_srs_job,
 )
+from app.services.testing_generation_service import (
+    build_testing_generation_response,
+    create_testing_generation,
+    delete_testing_generation,
+    list_testing_history,
+)
+from app.services.testing_generation_job_service import run_testing_generation_job
 from app.tools.registry import ToolRegistry
 from app.tools.srs_reqs_qwen import get_srs_tool
 
@@ -173,3 +193,223 @@ async def save_srs_requirements(
     db.refresh(extraction)
 
     return build_result_response(job, extraction)
+
+
+@router.get("/srs/history", response_model=List[SRSToolHistoryItem])
+async def get_srs_history(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> Any:
+    return list_srs_history(db, current_user.id)
+
+
+@router.delete("/srs/jobs/{job_id}")
+async def delete_srs_job_api(
+    job_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> Any:
+    job = (
+        db.query(ToolJob)
+        .filter(ToolJob.id == job_id, ToolJob.user_id == current_user.id)
+        .first()
+    )
+    if not job:
+        raise HTTPException(status_code=404, detail="任务不存在")
+
+    upload_path = build_srs_upload_path(job_id)
+    delete_srs_job(db, job)
+
+    if upload_path.exists():
+        shutil.rmtree(upload_path, ignore_errors=True)
+
+    return {"message": "删除成功"}
+
+
+@router.post("/testing/generations", response_model=TestingGenerationResultResponse)
+async def save_testing_generation(
+    payload: TestingGenerationSaveRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> Any:
+    if payload.source_job_id is not None:
+        source_job = (
+            db.query(ToolJob)
+            .filter(
+                ToolJob.id == payload.source_job_id,
+                ToolJob.user_id == current_user.id,
+            )
+            .first()
+        )
+        if not source_job:
+            raise HTTPException(status_code=404, detail="来源文件不存在")
+
+    if payload.knowledge_base_id is not None:
+        knowledge_base = (
+            db.query(KnowledgeBase)
+            .filter(
+                KnowledgeBase.id == payload.knowledge_base_id,
+                KnowledgeBase.user_id == current_user.id,
+            )
+            .first()
+        )
+        if not knowledge_base:
+            raise HTTPException(status_code=404, detail="知识库不存在")
+
+    return create_testing_generation(db, current_user.id, payload)
+
+
+@router.post("/testing/jobs", response_model=TestingGenerationCreateResponse)
+async def create_testing_generation_job(
+    background_tasks: BackgroundTasks,
+    payload: TestingGenerationCreateRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> Any:
+    if payload.source_job_id is not None:
+        source_job = (
+            db.query(ToolJob)
+            .filter(
+                ToolJob.id == payload.source_job_id,
+                ToolJob.user_id == current_user.id,
+            )
+            .first()
+        )
+        if not source_job:
+            raise HTTPException(status_code=404, detail="来源文件不存在")
+
+    if payload.knowledge_base_id is not None:
+        knowledge_base = (
+            db.query(KnowledgeBase)
+            .filter(
+                KnowledgeBase.id == payload.knowledge_base_id,
+                KnowledgeBase.user_id == current_user.id,
+            )
+            .first()
+        )
+        if not knowledge_base:
+            raise HTTPException(status_code=404, detail="知识库不存在")
+
+    job = ToolJob(
+        user_id=current_user.id,
+        tool_name="testing.case_generator",
+        status="pending",
+        input_file_name=payload.source_document_name,
+        input_file_path="",
+        output_summary={
+            "source_document_name": payload.source_document_name,
+            "current_step": 0,
+            "total_steps": len(payload.requirements),
+        },
+    )
+    db.add(job)
+    db.commit()
+    db.refresh(job)
+
+    background_tasks.add_task(
+        run_testing_generation_job,
+        job.id,
+        payload.dict(),
+    )
+
+    return {
+        "job_id": job.id,
+        "status": job.status,
+    }
+
+
+@router.get("/testing/jobs/{job_id}", response_model=TestingGenerationJobStatusResponse)
+async def get_testing_generation_job_status(
+    job_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> Any:
+    job = (
+        db.query(ToolJob)
+        .filter(
+            ToolJob.id == job_id,
+            ToolJob.user_id == current_user.id,
+        )
+        .first()
+    )
+    if not job:
+        raise HTTPException(status_code=404, detail="任务不存在")
+
+    summary = job.output_summary or {}
+    return {
+        "job_id": job.id,
+        "tool_name": job.tool_name,
+        "status": job.status,
+        "error_message": job.error_message,
+        "started_at": job.started_at,
+        "completed_at": job.completed_at,
+        "source_document_name": summary.get("source_document_name"),
+        "current_step": summary.get("current_step"),
+        "total_steps": summary.get("total_steps"),
+        "current_requirement_id": summary.get("current_requirement_id"),
+    }
+
+
+@router.get("/testing/history", response_model=List[TestingGenerationHistoryItem])
+async def get_testing_history(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> Any:
+    return list_testing_history(db, current_user.id)
+
+
+@router.get("/testing/jobs/{job_id}/result", response_model=TestingGenerationResultResponse)
+async def get_testing_generation_result(
+    job_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> Any:
+    job = (
+        db.query(ToolJob)
+        .filter(
+            ToolJob.id == job_id,
+            ToolJob.user_id == current_user.id,
+        )
+        .first()
+    )
+    if not job:
+        raise HTTPException(status_code=404, detail="任务不存在")
+
+    generation = (
+        db.query(TestingGeneration)
+        .filter(TestingGeneration.job_id == job.id)
+        .first()
+    )
+    if not generation:
+        raise HTTPException(status_code=404, detail="任务结果不存在")
+
+    return build_testing_generation_response(job, generation)
+
+
+@router.delete("/testing/jobs/{job_id}")
+async def delete_testing_generation_api(
+    job_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> Any:
+    job = (
+        db.query(ToolJob)
+        .filter(
+            ToolJob.id == job_id,
+            ToolJob.user_id == current_user.id,
+        )
+        .first()
+    )
+    if not job:
+        raise HTTPException(status_code=404, detail="任务不存在")
+
+    generation = (
+        db.query(TestingGeneration)
+        .filter(TestingGeneration.job_id == job.id)
+        .first()
+    )
+    if not generation:
+        raise HTTPException(status_code=404, detail="任务结果不存在")
+
+    delete_testing_generation(db, job)
+    return {"message": "删除成功"}