endo 0.3.0__py3-none-any.whl

endo/api/deps.py

@@ -0,0 +1,5 @@
+"""API 依赖注入"""
+
+from endo.core.database import get_db
+
+__all__ = ["get_db"]

endo/api/v1/analysis.py

@@ -0,0 +1,82 @@
+"""文档解析 API 路由"""
+
+import io
+
+from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
+from sqlalchemy.orm import Session
+
+from endo.api.deps import get_db
+from endo.models.requirement import Requirement
+from endo.schemas.analysis import (
+    ImportResult,
+    ImportToRequirementRequest,
+    ParseResultResponse,
+)
+from endo.services.document_parser import parse_document
+
+router = APIRouter()
+
+
+@router.post("/parse", response_model=ParseResultResponse)
+async def parse_file(file: UploadFile = File(...)):
+    """上传文件并解析出结构化技术要求"""
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="文件名不能为空")
+
+    content = await file.read()
+    if not content:
+        raise HTTPException(status_code=400, detail="文件内容为空")
+
+    # 限制文件大小 20MB
+    if len(content) > 20 * 1024 * 1024:
+        raise HTTPException(status_code=413, detail="文件过大，限制 20MB")
+
+    try:
+        result = parse_document(
+            io.BytesIO(content),
+            file.filename,
+            file.content_type or "",
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e)) from e
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"解析失败: {e}") from e
+
+    return result.to_dict()
+
+
+@router.post("/import", response_model=ImportResult, status_code=201)
+def import_to_requirements(
+    data: ImportToRequirementRequest,
+    db: Session = Depends(get_db),
+):
+    """将解析结果导入为需求条目"""
+    if not data.items:
+        raise HTTPException(status_code=400, detail="没有可导入的条目")
+
+    created: list[dict] = []
+    for item in data.items:
+        params = [p.model_dump() for p in item.parameters]
+        # 参数摘要追加到描述
+        param_summary = ""
+        if params:
+            param_summary = "\n\n关键参数:\n" + "\n".join(
+                f"- {p['name']} {p['operator']} {p['value']} {p['unit']}".strip() for p in params
+            )
+
+        req = Requirement(
+            project_id=data.project_id,
+            req_code=item.raw_code or f"REQ-{item.index:03d}",
+            title=item.title or f"导入条目 {item.index}",
+            description=item.content + param_summary,
+            category=item.category,
+            priority=data.default_priority,
+            source=data.default_source or "文档解析导入",
+            created_by=data.created_by,
+            structural_constraints={"parameters": params} if params else None,
+        )
+        db.add(req)
+        created.append({"req_code": req.req_code, "title": req.title})
+
+    db.commit()
+    return ImportResult(imported=len(created), items=created)

endo/api/v1/attachments.py

@@ -0,0 +1,206 @@
+"""附件管理 API 路由"""
+
+import uuid
+from pathlib import Path
+
+from fastapi import (
+    APIRouter,
+    Depends,
+    File,
+    Form,
+    HTTPException,
+    Query,
+    UploadFile,
+)
+from fastapi.responses import FileResponse
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session
+
+from endo.api.deps import get_db
+from endo.core.config import settings
+from endo.models.attachment import Attachment
+from endo.schemas.attachment import (
+    AttachmentListResponse,
+    AttachmentResponse,
+    AttachmentUpdate,
+)
+
+router = APIRouter()
+
+# 允许的关联实体类型
+ALLOWED_ENTITY_TYPES = {"project", "requirement", "test_case", "test_execution"}
+
+# 最大文件大小 100MB
+MAX_FILE_SIZE = 100 * 1024 * 1024
+
+
+def _get_upload_dir() -> Path:
+    """确保上传目录存在"""
+    upload_dir = settings.UPLOAD_DIR
+    upload_dir.mkdir(parents=True, exist_ok=True)
+    return upload_dir
+
+
+def _format_file_size(size: int) -> str:
+    """格式化文件大小"""
+    for unit in ["B", "KB", "MB", "GB"]:
+        if size < 1024:
+            return f"{size:.1f}{unit}"
+        size /= 1024
+    return f"{size:.1f}TB"
+
+
+@router.post("/upload", response_model=AttachmentResponse, status_code=201)
+async def upload_attachment(
+    entity_type: str = Form(..., description="关联实体类型"),
+    entity_id: str = Form(..., description="关联实体ID"),
+    title: str | None = Form(None, description="附件标题"),
+    description: str | None = Form(None, description="附件描述"),
+    category: str = Form("general", description="分类"),
+    uploaded_by: str | None = Form(None, description="上传人"),
+    file: UploadFile = File(..., description="文件"),
+    db: Session = Depends(get_db),
+):
+    """上传附件文件"""
+    if entity_type not in ALLOWED_ENTITY_TYPES:
+        allowed = ", ".join(sorted(ALLOWED_ENTITY_TYPES))
+        raise HTTPException(
+            status_code=400,
+            detail=f"不支持的实体类型: {entity_type}（支持: {allowed}）",
+        )
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="文件名不能为空")
+
+    content = await file.read()
+    if not content:
+        raise HTTPException(status_code=400, detail="文件内容为空")
+    if len(content) > MAX_FILE_SIZE:
+        raise HTTPException(
+            status_code=413, detail=f"文件过大，限制 {_format_file_size(MAX_FILE_SIZE)}"
+        )
+
+    # 生成存储文件名：UUID + 原扩展名
+    ext = Path(file.filename).suffix.lower()
+    stored_filename = f"{uuid.uuid4().hex}{ext}"
+    # 按实体类型分子目录，避免单目录文件过多
+    sub_dir = _get_upload_dir() / entity_type
+    sub_dir.mkdir(parents=True, exist_ok=True)
+    file_path = sub_dir / stored_filename
+    relative_path = f"{entity_type}/{stored_filename}"
+
+    # 写入磁盘
+    with file_path.open("wb") as f:
+        f.write(content)
+
+    # 保存元数据
+    attachment = Attachment(
+        entity_type=entity_type,
+        entity_id=entity_id,
+        filename=file.filename,
+        stored_filename=stored_filename,
+        file_path=relative_path,
+        file_size=len(content),
+        content_type=file.content_type,
+        title=title,
+        description=description,
+        category=category,
+        uploaded_by=uploaded_by,
+    )
+    db.add(attachment)
+    db.commit()
+    db.refresh(attachment)
+    return attachment
+
+
+@router.get("/", response_model=AttachmentListResponse)
+def list_attachments(
+    entity_type: str | None = Query(None, description="按实体类型筛选"),
+    entity_id: str | None = Query(None, description="按实体ID筛选"),
+    category: str | None = Query(None, description="按分类筛选"),
+    page: int = Query(1, ge=1),
+    page_size: int = Query(50, ge=1, le=200),
+    db: Session = Depends(get_db),
+):
+    """列出附件"""
+    stmt = select(Attachment)
+    if entity_type:
+        stmt = stmt.where(Attachment.entity_type == entity_type)
+    if entity_id:
+        stmt = stmt.where(Attachment.entity_id == entity_id)
+    if category:
+        stmt = stmt.where(Attachment.category == category)
+
+    count_stmt = select(func.count()).select_from(stmt.subquery())
+    total = db.scalar(count_stmt) or 0
+
+    stmt = stmt.order_by(Attachment.created_at.desc())
+    stmt = stmt.offset((page - 1) * page_size).limit(page_size)
+    items = db.scalars(stmt).all()
+
+    return AttachmentListResponse(
+        items=[AttachmentResponse.model_validate(i) for i in items],
+        total=total,
+    )
+
+
+@router.get("/{attachment_id}", response_model=AttachmentResponse)
+def get_attachment(attachment_id: str, db: Session = Depends(get_db)):
+    """获取附件元数据"""
+    attachment = db.get(Attachment, attachment_id)
+    if not attachment:
+        raise HTTPException(status_code=404, detail="附件不存在")
+    return attachment
+
+
+@router.patch("/{attachment_id}", response_model=AttachmentResponse)
+def update_attachment(
+    attachment_id: str,
+    data: AttachmentUpdate,
+    db: Session = Depends(get_db),
+):
+    """更新附件元数据（标题/描述/分类）"""
+    attachment = db.get(Attachment, attachment_id)
+    if not attachment:
+        raise HTTPException(status_code=404, detail="附件不存在")
+
+    update_data = data.model_dump(exclude_unset=True)
+    for key, value in update_data.items():
+        setattr(attachment, key, value)
+
+    db.commit()
+    db.refresh(attachment)
+    return attachment
+
+
+@router.delete("/{attachment_id}", status_code=204)
+def delete_attachment(attachment_id: str, db: Session = Depends(get_db)):
+    """删除附件（同时删除磁盘文件）"""
+    attachment = db.get(Attachment, attachment_id)
+    if not attachment:
+        raise HTTPException(status_code=404, detail="附件不存在")
+
+    # 删除磁盘文件
+    file_path = settings.UPLOAD_DIR / attachment.file_path
+    if file_path.exists():
+        file_path.unlink()
+
+    db.delete(attachment)
+    db.commit()
+
+
+@router.get("/{attachment_id}/download")
+def download_attachment(attachment_id: str, db: Session = Depends(get_db)):
+    """下载附件文件"""
+    attachment = db.get(Attachment, attachment_id)
+    if not attachment:
+        raise HTTPException(status_code=404, detail="附件不存在")
+
+    file_path = settings.UPLOAD_DIR / attachment.file_path
+    if not file_path.exists():
+        raise HTTPException(status_code=404, detail="文件不存在或已被删除")
+
+    return FileResponse(
+        path=str(file_path),
+        filename=attachment.filename,
+        media_type=attachment.content_type or "application/octet-stream",
+    )

endo/api/v1/exports.py

@@ -0,0 +1,133 @@
+"""导出 API 路由 - 需求规格书/追溯矩阵/测试报告"""
+
+import io
+from datetime import datetime
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi.responses import StreamingResponse
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from endo.api.deps import get_db
+from endo.models.project import Project
+from endo.models.requirement import (
+    Requirement,
+    RequirementTraceability,
+)
+from endo.models.test import TestCase, TestExecution
+from endo.services.export_service import (
+    export_requirement_spec_pdf,
+    export_test_report_pdf,
+    export_traceability_excel,
+)
+
+router = APIRouter()
+
+
+def _get_project_info(db: Session, project_id: str | None) -> tuple[str, str]:
+    """获取项目名称和编号"""
+    if not project_id:
+        return "", ""
+    project = db.get(Project, project_id)
+    if not project:
+        return "", ""
+    return project.name, project.code
+
+
+def _build_filename(prefix: str, project_code: str, ext: str) -> str:
+    """构造导出文件名"""
+    code = project_code or "all"
+    date_str = datetime.now().strftime("%Y%m%d")
+    return f"{prefix}_{code}_{date_str}.{ext}"
+
+
+@router.get("/requirements/spec")
+def export_requirements(
+    project_id: str | None = Query(None, description="按项目筛选"),
+    db: Session = Depends(get_db),
+):
+    """导出需求规格书 PDF"""
+    stmt = select(Requirement).order_by(Requirement.req_code)
+    if project_id:
+        stmt = stmt.where(Requirement.project_id == project_id)
+
+    requirements = db.scalars(stmt).all()
+    if not requirements:
+        raise HTTPException(status_code=404, detail="没有可导出的需求")
+
+    project_name, project_code = _get_project_info(db, project_id)
+    pdf_bytes = export_requirement_spec_pdf(requirements, project_name, project_code)
+
+    filename = _build_filename("需求规格书", project_code, "pdf")
+    return StreamingResponse(
+        io.BytesIO(pdf_bytes),
+        media_type="application/pdf",
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )
+
+
+@router.get("/traceability/matrix")
+def export_traceability(
+    project_id: str | None = Query(None, description="按项目筛选"),
+    db: Session = Depends(get_db),
+):
+    """导出追溯矩阵 Excel"""
+    # 获取需求
+    req_stmt = select(Requirement)
+    if project_id:
+        req_stmt = req_stmt.where(Requirement.project_id == project_id)
+    requirements = db.scalars(req_stmt).all()
+
+    # 获取追溯关系
+    trace_stmt = select(RequirementTraceability)
+    if project_id:
+        req_ids = {r.id for r in requirements}
+        if not req_ids:
+            trace_stmt = trace_stmt.where(False)
+        else:
+            trace_stmt = trace_stmt.where(RequirementTraceability.source_req_id.in_(req_ids))
+
+    traceability = db.scalars(trace_stmt).all()
+
+    if not requirements and not traceability:
+        raise HTTPException(status_code=404, detail="没有可导出的追溯数据")
+
+    excel_bytes = export_traceability_excel(traceability, requirements)
+
+    _, project_code = _get_project_info(db, project_id)
+    filename = _build_filename("追溯矩阵", project_code, "xlsx")
+    return StreamingResponse(
+        io.BytesIO(excel_bytes),
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )
+
+
+@router.get("/tests/report")
+def export_test_report(
+    project_id: str | None = Query(None, description="按项目筛选"),
+    db: Session = Depends(get_db),
+):
+    """导出测试报告 PDF"""
+    case_stmt = select(TestCase).order_by(TestCase.case_code)
+    if project_id:
+        case_stmt = case_stmt.where(TestCase.project_id == project_id)
+
+    test_cases = db.scalars(case_stmt).all()
+    if not test_cases:
+        raise HTTPException(status_code=404, detail="没有可导出的测试用例")
+
+    # 获取这些用例的执行记录
+    case_ids = {c.id for c in test_cases}
+    exec_stmt = select(TestExecution).where(TestExecution.test_case_id.in_(case_ids))
+    executions = db.scalars(exec_stmt).all()
+
+    project_name, project_code = _get_project_info(db, project_id)
+    pdf_bytes = export_test_report_pdf(test_cases, executions, project_name, project_code)
+
+    filename = _build_filename("测试报告", project_code, "pdf")
+    return StreamingResponse(
+        io.BytesIO(pdf_bytes),
+        media_type="application/pdf",
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )

endo/api/v1/projects.py

@@ -0,0 +1,96 @@
+"""项目 API 路由"""
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session
+
+from endo.api.deps import get_db
+from endo.models.project import Project
+from endo.models.requirement import Requirement
+from endo.schemas.project import ProjectCreate, ProjectResponse, ProjectUpdate
+
+router = APIRouter()
+
+
+def _with_requirement_count(stmt, db: Session):
+    """为查询结果附加 requirement_count"""
+    count_sub = (
+        select(Requirement.project_id, func.count().label("cnt"))
+        .group_by(Requirement.project_id)
+        .subquery()
+    )
+    stmt = stmt.outerjoin(count_sub, Project.id == count_sub.c.project_id)
+    stmt = stmt.add_columns(func.coalesce(count_sub.c.cnt, 0).label("requirement_count"))
+    return stmt
+
+
+# ---------- 项目统计（必须在 /{project_id} 之前定义）----------
+
+
+@router.get("/statistics/summary")
+def get_project_statistics(db: Session = Depends(get_db)):
+    """获取项目统计摘要"""
+    total = db.scalar(select(func.count()).select_from(Project)) or 0
+    by_status_rows = db.execute(select(Project.status, func.count()).group_by(Project.status)).all()
+    by_status = {row[0]: row[1] for row in by_status_rows}
+    return {"total": total, "by_status": by_status}
+
+
+# ---------- 项目 CRUD ----------
+
+
+@router.post("/", response_model=ProjectResponse, status_code=201)
+def create_project(data: ProjectCreate, db: Session = Depends(get_db)):
+    project = Project(**data.model_dump())
+    db.add(project)
+    db.commit()
+    db.refresh(project)
+    return ProjectResponse.model_validate(project)
+
+
+@router.get("/", response_model=list[ProjectResponse])
+def list_projects(db: Session = Depends(get_db)):
+    stmt = select(Project).order_by(Project.created_at.desc())
+    stmt = _with_requirement_count(stmt, db)
+    rows = db.execute(stmt).all()
+    results = []
+    for row in rows:
+        proj_data = ProjectResponse.model_validate(row[0])
+        proj_data.requirement_count = row[1]
+        results.append(proj_data)
+    return results
+
+
+@router.get("/{project_id}", response_model=ProjectResponse)
+def get_project(project_id: str, db: Session = Depends(get_db)):
+    project = db.get(Project, project_id)
+    if not project:
+        raise HTTPException(status_code=404, detail="项目不存在")
+    count = db.scalar(select(func.count()).where(Requirement.project_id == project_id)) or 0
+    resp = ProjectResponse.model_validate(project)
+    resp.requirement_count = count
+    return resp
+
+
+@router.put("/{project_id}", response_model=ProjectResponse)
+def update_project(project_id: str, data: ProjectUpdate, db: Session = Depends(get_db)):
+    project = db.get(Project, project_id)
+    if not project:
+        raise HTTPException(status_code=404, detail="项目不存在")
+    for key, value in data.model_dump(exclude_unset=True).items():
+        setattr(project, key, value)
+    db.commit()
+    db.refresh(project)
+    count = db.scalar(select(func.count()).where(Requirement.project_id == project_id)) or 0
+    resp = ProjectResponse.model_validate(project)
+    resp.requirement_count = count
+    return resp
+
+
+@router.delete("/{project_id}", status_code=204)
+def delete_project(project_id: str, db: Session = Depends(get_db)):
+    project = db.get(Project, project_id)
+    if not project:
+        raise HTTPException(status_code=404, detail="项目不存在")
+    db.delete(project)
+    db.commit()