bid-master-cli 1.0.0__py3-none-any.whl

app/api/database.py

@@ -0,0 +1,286 @@
+"""
+文件管理 API 路由：统一的 CRUD 接口，覆盖文件/模拟/开标/提取四大模块。
+当前使用内存 mock 数据，数据库连接后将切换为 Drizzle ORM。
+所有端点强制认证，按 user_id 隔离数据。
+"""
+import io
+import json
+import zipfile
+from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi.responses import StreamingResponse
+from typing import Optional
+from urllib.parse import quote
+
+from pydantic import BaseModel
+
+from app.infrastructure.pg_storage import (
+    get_stats, list_files, get_file, delete_file,
+    list_simulates, get_simulate, delete_simulate,
+    list_openings, get_opening, delete_opening,
+    list_extracts, get_extract, delete_extract,
+)
+from app.services.file_service import get_file_service
+from app.utils.auth_dep import get_current_user
+
+router = APIRouter(prefix="/data", tags=["data"])
+
+
+class BatchDownloadRequest(BaseModel):
+    file_ids: list[str]
+
+
+# --- 统计概览 ---
+
+
+@router.get("/stats")
+async def api_get_stats(current_user: dict = Depends(get_current_user)):
+    """获取各模块数据总数。"""
+    return await get_stats(user_id=current_user["id"])
+
+
+# --- 文件管理 ---
+
+
+@router.get("/files")
+async def api_list_files(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    file_type: Optional[str] = None,
+    current_user: dict = Depends(get_current_user),
+):
+    """分页列出文件，可按类型筛选。"""
+    return await list_files(page, page_size, file_type, user_id=current_user["id"])
+
+
+@router.get("/files/{file_id}")
+async def api_get_file(file_id: str, current_user: dict = Depends(get_current_user)):
+    """获取单个文件详情。"""
+    record = await get_file(file_id, user_id=current_user["id"])
+    if not record:
+        raise HTTPException(status_code=404, detail="File not found")
+    return {"file": record}
+
+
+@router.delete("/files/{file_id}")
+async def api_delete_file(file_id: str, current_user: dict = Depends(get_current_user)):
+    """删除文件。"""
+    deleted = await delete_file(file_id, user_id=current_user["id"])
+    if not deleted:
+        raise HTTPException(status_code=404, detail="File not found")
+    return {"success": True}
+
+
+@router.get("/files/{file_id}/download")
+async def api_download_file(file_id: str, current_user: dict = Depends(get_current_user)):
+    """下载原始文件（加密存储，解密后返回）。"""
+    record = await get_file(file_id, user_id=current_user["id"])
+    if not record:
+        raise HTTPException(status_code=404, detail="File not found")
+    try:
+        file_service = get_file_service()
+        content = await file_service.download(file_id, current_user["id"])
+        filename = record.get("original_name", file_id)
+        encoded_filename = quote(filename)
+        return StreamingResponse(
+            iter([content]),
+            media_type="application/octet-stream",
+            headers={
+                "Content-Disposition": f"attachment; filename=\"{encoded_filename}\"; filename*=UTF-8''{encoded_filename}"
+            }
+        )
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="文件不存在（演示数据无法下载，请上传真实文件）")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/files/{file_id}/preview")
+async def api_preview_file(file_id: str, current_user: dict = Depends(get_current_user)):
+    """预览文件（inline 返回，浏览器直接渲染）。"""
+    record = await get_file(file_id, user_id=current_user["id"])
+    if not record:
+        raise HTTPException(status_code=404, detail="File not found")
+    try:
+        file_service = get_file_service()
+        content = await file_service.download(file_id, current_user["id"])
+        mime_map = {
+            "pdf": "application/pdf",
+            "word": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            "excel": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            "csv": "text/csv",
+            "markdown": "text/markdown",
+        }
+        mime_type = mime_map.get(record.get("type", ""), "application/octet-stream")
+        filename = record.get("original_name", file_id)
+        encoded_filename = quote(filename)
+        return StreamingResponse(
+            iter([content]),
+            media_type=mime_type,
+            headers={
+                "Content-Disposition": f"inline; filename=\"{encoded_filename}\"; filename*=UTF-8''{encoded_filename}"
+            }
+        )
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="文件不存在（演示数据无法预览，请上传真实文件）")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/files/batch-download")
+async def api_batch_download_files(body: BatchDownloadRequest, current_user: dict = Depends(get_current_user)):
+    """批量下载文件，打包为 ZIP 返回。"""
+    if not body.file_ids:
+        raise HTTPException(status_code=400, detail="file_ids 不能为空")
+
+    zip_buffer = io.BytesIO()
+    file_service = get_file_service()
+
+    with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+        for file_id in body.file_ids:
+            record = await get_file(file_id, user_id=current_user["id"])
+            if not record:
+                continue
+            try:
+                content = await file_service.download(file_id, current_user["id"])
+                filename = record.get("original_name", file_id)
+                # 去重：同名文件加 ID 后缀
+                info = zf.NameToInfo.get(filename)
+                if info is not None:
+                    name, ext = filename.rsplit(".", 1) if "." in filename else (filename, "")
+                    filename = f"{name}_{file_id[:8]}.{ext}" if ext else f"{name}_{file_id[:8]}"
+                zf.writestr(filename, content)
+            except FileNotFoundError:
+                continue
+            except Exception:
+                continue
+
+    zip_buffer.seek(0)
+    return StreamingResponse(
+        iter([zip_buffer.getvalue()]),
+        media_type="application/zip",
+        headers={
+            "Content-Disposition": "attachment; filename=\"batch_download.zip\""
+        }
+    )
+
+
+# --- 模拟任务 ---
+
+
+@router.get("/simulates")
+async def api_list_simulates(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    status: Optional[str] = None,
+    current_user: dict = Depends(get_current_user),
+):
+    """分页列出模拟任务，可按状态筛选。"""
+    return await list_simulates(page, page_size, status, user_id=current_user["id"])
+
+
+@router.get("/simulates/{task_id}")
+async def api_get_simulate(task_id: str, current_user: dict = Depends(get_current_user)):
+    """获取模拟任务详情。"""
+    record = await get_simulate(task_id, user_id=current_user["id"])
+    if not record:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return {"task": record}
+
+
+@router.delete("/simulates/{task_id}")
+async def api_delete_simulate(task_id: str, current_user: dict = Depends(get_current_user)):
+    """删除模拟任务。"""
+    deleted = await delete_simulate(task_id, user_id=current_user["id"])
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return {"success": True}
+
+
+# --- 开标结果 ---
+
+
+@router.get("/openings")
+async def api_list_openings(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    current_user: dict = Depends(get_current_user),
+):
+    """分页列出开标分析结果。"""
+    return await list_openings(page, page_size, user_id=current_user["id"])
+
+
+@router.get("/openings/{task_id}")
+async def api_get_opening(task_id: str, current_user: dict = Depends(get_current_user)):
+    """获取开标结果详情。"""
+    record = await get_opening(task_id, user_id=current_user["id"])
+    if not record:
+        raise HTTPException(status_code=404, detail="Result not found")
+    return record
+
+
+@router.delete("/openings/{task_id}")
+async def api_delete_opening(task_id: str, current_user: dict = Depends(get_current_user)):
+    """删除开标结果。"""
+    deleted = await delete_opening(task_id, user_id=current_user["id"])
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Result not found")
+    return {"success": True}
+
+
+# --- 提取结果 ---
+
+
+@router.get("/extracts")
+async def api_list_extracts(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    current_user: dict = Depends(get_current_user),
+):
+    """分页列出提取结果。"""
+    return await list_extracts(page, page_size, user_id=current_user["id"])
+
+
+@router.get("/extracts/{result_id}")
+async def api_get_extract(result_id: str, current_user: dict = Depends(get_current_user)):
+    """获取提取结果详情。"""
+    record = await get_extract(result_id, user_id=current_user["id"])
+    if not record:
+        raise HTTPException(status_code=404, detail="Result not found")
+    return record
+
+
+@router.get("/extracts/{result_id}/export-json")
+async def api_export_extract_json(result_id: str, current_user: dict = Depends(get_current_user)):
+    record = await get_extract(result_id, user_id=current_user["id"])
+    if not record:
+        raise HTTPException(status_code=404, detail="Result not found")
+
+    payload = {
+        "id": record.get("id"),
+        "file_id": record.get("file_id"),
+        "file_name": record.get("file_name") or record.get("name"),
+        "template_type": record.get("template_type"),
+        "mode": record.get("mode"),
+        "status": record.get("status"),
+        "created_at": record.get("created_at"),
+        "elements": record.get("elements") or [],
+        "markdown_content": record.get("content") or "",
+    }
+    content = json.dumps(payload, ensure_ascii=False, indent=2).encode("utf-8")
+    filename = quote(f"extract_{result_id}.json")
+    return StreamingResponse(
+        iter([content]),
+        media_type="application/json",
+        headers={
+            "Content-Disposition": f"attachment; filename=\"{filename}\"; filename*=UTF-8''{filename}"
+        },
+    )
+
+
+@router.delete("/extracts/{result_id}")
+async def api_delete_extract(result_id: str, current_user: dict = Depends(get_current_user)):
+    """删除提取结果。"""
+    deleted = await delete_extract(result_id, user_id=current_user["id"])
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Result not found")
+    return {"success": True}

app/api/extract.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+"""
+Document extraction API routes with SSE support.
+所有端点强制认证，提取结果归属当前用户。
+"""
+import json
+from fastapi import APIRouter, Depends, HTTPException, Request
+from sse_starlette.sse import EventSourceResponse
+
+from app.services.extract_service import ExtractService
+from app.models.schemas import ExtractRequest, BatchExtractRequest, ThresholdRequest
+from app.limiter import limiter
+from app.utils.auth_dep import get_current_user
+
+router = APIRouter(prefix="/extract", tags=["extract"])
+
+
+async def extract_elements_generator(
+    document_id: str,
+    provider: str = "deepseek",
+    model: str = None,
+    template_type: str = "standard",
+    elements: list[str] = None,
+    mode: str = "single",
+    params: dict = None,
+    user_id: str = None,
+):
+    """
+    Generate SSE events for element extraction.
+    Yields properly JSON-encoded data for SSE.
+    """
+    extract_service = ExtractService()
+
+    async for event in extract_service.extract_elements_stream(
+        document_id, provider, model, template_type, elements, mode, params, user_id=user_id
+    ):
+        yield {
+            "event": event.get("type", "message"),
+            "data": json.dumps(event, ensure_ascii=False),
+        }
+
+
+@router.post("/element")
+@limiter.limit("20/minute")
+async def extract_element(request: Request, current_user: dict = Depends(get_current_user)):
+    """单文件要素提取（SSE 流式）。限速 20次/分钟。"""
+    body = await request.json()
+    req = ExtractRequest(**body)
+    return EventSourceResponse(
+        extract_elements_generator(
+            req.fileId,
+            req.provider or "deepseek",
+            req.model,
+            req.template_type or "standard",
+            req.elements,
+            req.mode or "single",
+            user_id=current_user["id"],
+        )
+    )
+
+
+# =============================================================================
+# Batch & Threshold endpoints
+# =============================================================================
+
+
+async def extract_batch_generator(
+    file_ids: list[str],
+    provider: str = "deepseek",
+    model: str = None,
+    elements: list[str] = None,
+    user_id: str = None,
+):
+    extract_service = ExtractService()
+    async for event in extract_service.extract_batch_stream(file_ids, provider, model, elements, user_id=user_id):
+        yield {
+            "event": event.get("type", "message"),
+            "data": json.dumps(event, ensure_ascii=False),
+        }
+
+
+@router.post("/element/batch")
+@limiter.limit("10/minute")
+async def extract_batch(request: Request, current_user: dict = Depends(get_current_user)):
+    """批量对比：多文件并行提取 + 横向对比分析。限速 10次/分钟。"""
+    body = await request.json()
+    req = BatchExtractRequest(**body)
+    if len(req.fileIds) < 2:
+        raise HTTPException(status_code=400, detail="批量对比需要至少 2 个文件")
+    return EventSourceResponse(
+        extract_batch_generator(
+            req.fileIds,
+            req.provider or "deepseek",
+            req.model,
+            req.elements,
+            user_id=current_user["id"],
+        )
+    )
+
+
+async def extract_threshold_generator(
+    file_id: str,
+    user_qualifications: str,
+    provider: str = "deepseek",
+    model: str = None,
+    user_id: str = None,
+):
+    extract_service = ExtractService()
+    async for event in extract_service.extract_threshold_stream(
+        file_id, user_qualifications, provider, model, user_id=user_id
+    ):
+        yield {
+            "event": event.get("type", "message"),
+            "data": json.dumps(event, ensure_ascii=False),
+        }
+
+
+@router.post("/element/threshold")
+@limiter.limit("20/minute")
+async def extract_threshold(request: Request, current_user: dict = Depends(get_current_user)):
+    """门槛分析：招标文件要求 vs 用户自身条件逐项比对。限速 20次/分钟。"""
+    body = await request.json()
+    req = ThresholdRequest(**body)
+    if not req.userQualifications.strip():
+        raise HTTPException(status_code=400, detail="请填写自身资质、业绩条件")
+    return EventSourceResponse(
+        extract_threshold_generator(
+            req.fileId,
+            req.userQualifications,
+            req.provider or "deepseek",
+            req.model,
+            user_id=current_user["id"],
+        )
+    )
+
+
+@router.get("/status/{task_id}")
+async def get_extract_status(task_id: str, current_user: dict = Depends(get_current_user)):
+    """获取提取任务状态（兼容旧版 task_id 查询）。"""
+    from app.infrastructure.pg_storage import get_extract
+    result = await get_extract(task_id, user_id=current_user["id"])
+    if result:
+        return {"success": True, "data": result}
+    return {
+        "success": True,
+        "data": {"taskId": task_id, "status": "unknown", "progress": 0}
+    }
+
+
+@router.get("/result/by-file/{file_id}")
+async def get_extract_result_by_file(file_id: str, current_user: dict = Depends(get_current_user)):
+    """根据文件 ID 获取最新的提取结果。"""
+    from app.infrastructure.pg_storage import list_extracts
+    results = await list_extracts(page=1, page_size=50, user_id=current_user["id"])
+    for r in results.get("results", []):
+        if r.get("file_id") == file_id:
+            return {"success": True, "data": r}
+    return {"success": False, "data": None, "message": "未找到提取结果"}

app/api/files.py

@@ -0,0 +1,163 @@
+"""
+File management API routes.
+所有端点强制认证，文件归属当前用户。
+"""
+from fastapi import APIRouter, Depends, UploadFile, File, HTTPException, Query
+from fastapi.responses import StreamingResponse
+from pathlib import Path
+from typing import Optional
+from urllib.parse import quote
+
+from app.services.file_service import FileService
+from app.models.schemas import FileUploadResponse, FileListResponse, FileListItem
+from app.utils.exceptions import FileTooLargeError, UnsupportedFileTypeError
+from app.infrastructure.pg_storage import add_file, list_files as pg_list_files, get_file as pg_get_file, delete_file as pg_delete_file, _now, calculate_content_hash
+from app.utils.auth_dep import get_current_user
+
+router = APIRouter(prefix="/files", tags=["files"])
+
+MIME_TYPE_EXTENSIONS = {
+    "application/pdf": "pdf",
+    "text/markdown": "md",
+    "application/msword": "doc",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+    "application/vnd.ms-excel": "xls",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+    "text/csv": "csv",
+}
+
+
+def normalize_file_type(filename: str, mime_type: str) -> str:
+    suffix = Path(filename or "").suffix.lower().lstrip(".")
+    if suffix:
+        return suffix[:50]
+    return MIME_TYPE_EXTENSIONS.get(mime_type, (mime_type.rsplit("/", 1)[-1] if mime_type else "file"))[:50]
+
+
+@router.post("/upload")
+async def upload_file(
+    file: UploadFile = File(...),
+    category: str = Query("tender", description="Document category: tender or bid"),
+    current_user: dict = Depends(get_current_user),
+):
+    """
+    Upload and encrypt a file.
+    """
+    try:
+        content = await file.read()
+        file_service = FileService()
+        result = await file_service.upload(
+            file_content=content,
+            filename=file.filename,
+            mime_type=file.content_type or "application/octet-stream",
+            category=category,
+        )
+
+        await add_file({
+            "id": result["id"],
+            "original_name": result["name"],
+            "path": result["encrypted_path"],
+            "size": result["size"],
+            "type": normalize_file_type(result["name"], result["mime_type"]),
+            "file_hash": calculate_content_hash(content),
+            "created_at": _now(),
+        }, user_id=current_user["id"], encrypted_content=result["encrypted_content"])
+
+        return {
+            "success": True,
+            "data": {
+                "id": result["id"],
+                "name": result["name"],
+                "size": result["size"],
+                "type": result["mime_type"],
+                "status": result["status"],
+                "createdAt": result.get("created_at", ""),
+            }
+        }
+
+    except FileTooLargeError as e:
+        raise HTTPException(status_code=413, detail=str(e))
+    except UnsupportedFileTypeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/list")
+async def list_files(
+    page: int = Query(1, ge=1),
+    limit: int = Query(10, ge=1, le=100),
+    file_type: Optional[str] = None,
+    current_user: dict = Depends(get_current_user),
+):
+    """List uploaded files."""
+    result = await pg_list_files(page, limit, file_type, user_id=current_user["id"])
+    return {
+        "success": True,
+        "data": {
+            "files": result["files"],
+            "total": result["total"],
+        },
+        "pagination": {
+            "page": result["page"],
+            "limit": limit,
+            "total": result["total"],
+        }
+    }
+
+
+@router.get("/{file_id}")
+async def get_file(file_id: str, current_user: dict = Depends(get_current_user)):
+    """Get file metadata."""
+    record = await pg_get_file(file_id, user_id=current_user["id"])
+    if not record:
+        raise HTTPException(status_code=404, detail="File not found")
+    return {
+        "success": True,
+        "data": {
+            "id": record["id"],
+            "name": record["original_name"],
+            "size": record["size"],
+            "mimeType": record.get("type", ""),
+            "status": "ready",
+        }
+    }
+
+
+@router.get("/{file_id}/download")
+async def download_file(file_id: str, current_user: dict = Depends(get_current_user)):
+    """Download and decrypt a file."""
+    record = await pg_get_file(file_id, user_id=current_user["id"])
+    if not record:
+        raise HTTPException(status_code=404, detail="File not found")
+    filename = record.get("original_name", f"{file_id}.pdf")
+    try:
+        file_service = FileService()
+        content = await file_service.download(file_id, current_user["id"])
+        encoded_filename = quote(filename)
+        return StreamingResponse(
+            iter([content]),
+            media_type="application/octet-stream",
+            headers={
+                "Content-Disposition": f"attachment; filename=\"{encoded_filename}\"; filename*=UTF-8''{encoded_filename}"
+            }
+        )
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="File not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/{file_id}")
+async def delete_file(file_id: str, current_user: dict = Depends(get_current_user)):
+    """Delete an encrypted file."""
+    try:
+        file_service = FileService()
+        deleted = await file_service.delete(file_id)
+        await pg_delete_file(file_id, user_id=current_user["id"])
+        return {
+            "success": deleted,
+            "message": "File deleted" if deleted else "File not found"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/api/health.py

@@ -0,0 +1,62 @@
+"""
+Health check API route.
+"""
+from fastapi import APIRouter
+from datetime import datetime
+import subprocess
+
+from app.models.schemas import HealthResponse
+
+router = APIRouter(tags=["health"])
+
+
+def _get_git_info() -> dict:
+    """获取 git 信息用于部署验证。"""
+    info = {}
+    try:
+        info["commit"] = subprocess.check_output(
+            ["git", "rev-parse", "--short", "HEAD"], stderr=subprocess.DEVNULL
+        ).decode().strip()
+    except Exception:
+        info["commit"] = "unknown"
+    try:
+        info["branch"] = subprocess.check_output(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"], stderr=subprocess.DEVNULL
+        ).decode().strip()
+    except Exception:
+        info["branch"] = "unknown"
+    return info
+
+
+@router.get("/health")
+async def health_check():
+    """
+    Health check endpoint.
+
+    Returns:
+        Service health status
+    """
+    git_info = _get_git_info()
+    return {
+        "status": "healthy",
+        "timestamp": datetime.utcnow().isoformat(),
+        "version": "1.0.0",
+        "git": git_info,
+    }
+
+
+@router.get("/")
+async def root():
+    """
+    Root endpoint.
+
+    Returns:
+        API information
+    """
+    git_info = _get_git_info()
+    return {
+        "name": "Bid Master API",
+        "version": "1.0.0",
+        "docs": "/docs",
+        "git": git_info,
+    }

app/api/logs.py

@@ -0,0 +1,26 @@
+"""
+日志查询 API 路由。
+"""
+from fastapi import APIRouter, Depends, Query
+from typing import Optional
+
+from app.utils.auth_dep import get_current_user
+from app.infrastructure.log_collector import get_logs, clear_logs
+
+router = APIRouter(prefix="/logs", tags=["logs"])
+
+
+@router.get("")
+async def list_logs(
+    limit: int = Query(100, ge=1, le=500),
+    level: Optional[str] = Query(None),
+    current_user: dict = Depends(get_current_user),
+):
+    logs = get_logs(limit=limit, level=level, user_id=current_user["id"])
+    return {"success": True, "logs": logs}
+
+
+@router.delete("")
+async def delete_logs(current_user: dict = Depends(get_current_user)):
+    count = clear_logs(user_id=current_user["id"])
+    return {"success": True, "deleted": count}