后端模块拆分

src/moldinsight/api/__init__.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter
+import importlib
+
+from shared.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+router = APIRouter()
+
+def _safe_include(module_path: str, label: str):
+    try:
+        module = importlib.import_module(module_path)
+        router_obj = getattr(module, "router", None)
+        if router_obj is None:
+            raise ValueError("未找到 router 对象")
+        router.include_router(router_obj)
+        logger.info(f"{label} 路由加载成功")
+    except Exception as exc:
+        logger.warning(f"{label} 路由加载失败，已跳过: {exc}")
+
+
+_safe_include("moldinsight.api.health_router", "健康检查")
+_safe_include("moldinsight.api.upload_router", "上传")
+_safe_include("moldinsight.api.task_router", "任务")
+_safe_include("moldinsight.api.history_router", "历史")
+_safe_include("moldinsight.api.debug_router", "调试")
+_safe_include("moldinsight.api.cam_router", "CAM")
+_safe_include("moldinsight.api.advanced_router", "高级")

src/moldinsight/api/advanced_router.py

@@ -0,0 +1,538 @@
+from pathlib import Path
+import os
+from datetime import datetime
+from urllib.parse import quote
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from shared.services.auth_service import get_current_active_user
+from shared.services.redis_task_manager import redis_task_manager
+from moldinsight.services.processing_service import processing_service
+from moldinsight.services.storage_integration_rustfs import StorageIntegrationService
+from moldinsight.services.task_query_service import TaskQueryService
+from shared.database.database import get_db_session
+from shared.models.database import User
+from shared.models.database import ProcessingTask, STPFile
+from moldinsight.core.cad_exporter import CADExporter
+from shared.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+router = APIRouter()
+cad_exporter = CADExporter()
+storage_service = StorageIntegrationService()
+
+_api_routes_cache = {}
+
+
+def _get_cached(key):
+    global _api_routes_cache
+    if key not in _api_routes_cache:
+        try:
+            from api import routes
+        except Exception as e:
+            logger.warning(f"api.routes 模块加载失败: {e}")
+            _api_routes_cache["__error__"] = str(e)
+            return None
+        _api_routes_cache.clear()
+        _api_routes_cache.update({
+            "tasks": routes.tasks,
+            "cavity_layout_optimizer": routes.cavity_layout_optimizer,
+            "mold_system_designer": routes.mold_system_designer,
+            "side_action_designer": routes.side_action_designer,
+            "mold_cam_designer": routes.mold_cam_designer,
+            "collision_detector": routes.collision_detector,
+            "toolpath_optimizer": routes.toolpath_optimizer,
+            "edm_designer": routes.edm_designer,
+            "machining_simulator": routes.machining_simulator,
+            "cad_exporter": routes.cad_exporter,
+        })
+    return _api_routes_cache.get(key)
+
+
+async def _get_task_data(task_id: str) -> dict:
+    task = await redis_task_manager.get_task(task_id)
+    if task:
+        return task
+    tasks = _get_cached("tasks")
+    if tasks and task_id in tasks:
+        return tasks[task_id]
+    return None
+
+
+async def _ensure_task_access(
+    db_session: AsyncSession,
+    task_id: str,
+    user_id: int,
+):
+    row = await db_session.execute(
+        select(ProcessingTask, STPFile)
+        .join(STPFile, ProcessingTask.stp_file_id == STPFile.id)
+        .where(ProcessingTask.task_id == task_id)
+    )
+    row = row.first()
+    if not row:
+        raise HTTPException(404, "任务不存在")
+
+    _, stp_file = row
+    owner_id = getattr(stp_file, "user_id", None)
+    if owner_id is not None and owner_id != user_id:
+        raise HTTPException(403, "无权访问该任务的导出文件")
+
+    return row
+
+
+def _get_export_artifacts(task_data: dict) -> dict:
+    if not isinstance(task_data, dict):
+        return {}
+    direct = task_data.get("export_artifacts")
+    if isinstance(direct, dict):
+        return direct
+    parameters = task_data.get("parameters")
+    if isinstance(parameters, dict) and isinstance(parameters.get("export_artifacts"), dict):
+        return parameters.get("export_artifacts")
+    return {}
+
+
+def _expand_components(components):
+    requested = components or ["cavity", "core"]
+    if "all" in requested:
+        return ["cavity", "core", "parting_surface"]
+    return list(dict.fromkeys(requested))
+
+
+def _augment_export_files(task_id: str, files):
+    items = []
+    for file in files or []:
+        item = dict(file)
+        relative_path = item.get("relative_path")
+        if not relative_path and item.get("filepath"):
+            relative_path = cad_exporter.get_relative_path(item["filepath"])
+        if relative_path:
+            relative_path = str(relative_path).replace("\\", "/").strip("/")
+            item["relative_path"] = relative_path
+            item["download_path"] = f"/api/export-download/{quote(relative_path, safe='/')}?task_id={task_id}"
+        items.append(item)
+    return items
+
+
+def _merge_export_artifacts(existing: dict, export_result: dict) -> dict:
+    merged = dict(existing or {})
+    schemes = dict(merged.get("schemes") or {})
+    scheme_id = export_result.get("scheme_id") or "default"
+    previous = dict(schemes.get(scheme_id) or {})
+
+    file_map = {}
+    for file in previous.get("files", []):
+        file_map[(file.get("component"), file.get("format"))] = file
+    for file in export_result.get("files", []):
+        file_map[(file.get("component"), file.get("format"))] = file
+
+    schemes[scheme_id] = {
+        "base_filename": export_result.get("base_filename") or previous.get("base_filename"),
+        "generated_at": datetime.now().isoformat(),
+        "files": sorted(
+            file_map.values(),
+            key=lambda item: (item.get("component", ""), item.get("format", "")),
+        ),
+        "errors": export_result.get("errors", []),
+        "total_files": len(file_map),
+        "total_errors": len(export_result.get("errors", [])),
+    }
+
+    merged["version"] = 1
+    merged["task_id"] = export_result.get("task_id") or merged.get("task_id")
+    merged["generated_at"] = merged.get("generated_at") or datetime.now().isoformat()
+    merged["schemes"] = schemes
+    return merged
+
+
+def _select_persisted_files(task_id: str, task_data: dict, scheme_id: str, formats, components):
+    artifacts = _get_export_artifacts(task_data)
+    scheme_data = (artifacts.get("schemes") or {}).get(scheme_id)
+    if not scheme_data:
+        return None
+
+    component_list = _expand_components(components)
+    format_list = list(dict.fromkeys(formats or ["step", "stl"]))
+    expected = {(component, fmt) for component in component_list for fmt in format_list}
+
+    available = []
+    available_keys = set()
+    for file in scheme_data.get("files", []):
+        component = file.get("component")
+        fmt = file.get("format")
+        if component not in component_list or fmt not in format_list:
+            continue
+        relative_path = str(file.get("relative_path") or "").replace("\\", "/").strip("/")
+        if not relative_path:
+            continue
+        full_path = os.path.join(cad_exporter.output_dir, relative_path.replace("/", os.sep))
+        if not os.path.exists(full_path):
+            continue
+        available.append(file)
+        available_keys.add((component, fmt))
+
+    if expected and not expected.issubset(available_keys):
+        return None
+
+    return _augment_export_files(task_id, available)
+
+
+@router.post("/optimize-layout")
+async def optimize_cavity_layout(
+    request: Request,
+    current_user: User = Depends(get_current_active_user),
+):
+    body = await request.json()
+    product_bbox = body.get("product_bbox", {"dimensions": [100, 100, 50]})
+    cavity_count = body.get("cavity_count", 1)
+    mold_base_size = body.get("mold_base_size")
+    layout_type = body.get("layout_type", "auto")
+    if cavity_count < 1 or cavity_count > 64:
+        raise HTTPException(400, "型腔数量必须在 1-64 之间")
+    optimizer = _get_cached("cavity_layout_optimizer")
+    if not optimizer:
+        raise HTTPException(503, "服务不可用：核心模块未加载")
+    result = optimizer.optimize_layout(
+        product_bbox=product_bbox,
+        cavity_count=cavity_count,
+        mold_base_size=mold_base_size,
+        layout_type=layout_type,
+    )
+    return {"status": "success", "data": result}
+
+
+@router.post("/design-cooling")
+async def design_cooling_system(
+    request: Request,
+    current_user: User = Depends(get_current_active_user),
+):
+    body = await request.json()
+    mold_size = body.get("mold_size", {"length": 300, "width": 300, "height": 200})
+    product_bbox = body.get("product_bbox", {"dimensions": [100, 100, 50]})
+    material = body.get("material", "ABS")
+    cavity_count = body.get("cavity_count", 1)
+    cycle_time_target = body.get("cycle_time_target")
+    from moldinsight.core.mold_system_designer import CoolingSystemDesigner
+    designer = CoolingSystemDesigner()
+    result = designer.design_cooling_system(
+        mold_size=mold_size, product_bbox=product_bbox,
+        material=material, cavity_count=cavity_count,
+        cycle_time_target=cycle_time_target,
+    )
+    return {"status": "success", "data": result}
+
+
+@router.post("/design-gating")
+async def design_gating_system(
+    request: Request,
+    current_user: User = Depends(get_current_active_user),
+):
+    body = await request.json()
+    product_bbox = body.get("product_bbox", {"dimensions": [100, 100, 50]})
+    material = body.get("material", "ABS")
+    cavity_count = body.get("cavity_count", 1)
+    gate_type = body.get("gate_type", "auto")
+    layout_positions = body.get("layout_positions")
+    from moldinsight.core.mold_system_designer import GatingSystemDesigner
+    designer = GatingSystemDesigner()
+    result = designer.design_gating_system(
+        product_bbox=product_bbox, material=material,
+        cavity_count=cavity_count, gate_type=gate_type,
+        layout_positions=layout_positions,
+    )
+    return {"status": "success", "data": result}
+
+
+@router.post("/design-mold-system")
+async def design_complete_mold_system(
+    request: Request,
+    current_user: User = Depends(get_current_active_user),
+):
+    body = await request.json()
+    mold_size = body.get("mold_size", {"length": 300, "width": 300, "height": 200})
+    product_bbox = body.get("product_bbox", {"dimensions": [100, 100, 50]})
+    material = body.get("material", "ABS")
+    cavity_count = body.get("cavity_count", 1)
+    gate_type = body.get("gate_type", "auto")
+    cycle_time_target = body.get("cycle_time_target")
+    layout_positions = body.get("layout_positions")
+    ds = _get_cached("mold_system_designer")
+    if not ds:
+        raise HTTPException(503, "服务不可用：核心模块未加载")
+    result = ds.design_complete_system(
+        mold_size=mold_size, product_bbox=product_bbox,
+        material=material, cavity_count=cavity_count,
+        gate_type=gate_type, cycle_time_target=cycle_time_target,
+        layout_positions=layout_positions,
+    )
+    return {"status": "success", "data": result}
+
+
+@router.post("/ai-parting-detect")
+async def ai_parting_surface_detect(
+    request: Request,
+    current_user: User = Depends(get_current_active_user),
+):
+    body = await request.json()
+    task_id = body.get("task_id")
+    if not task_id:
+        raise HTTPException(404, "缺少 task_id")
+    task_data = await _get_task_data(task_id)
+    if not task_data:
+        raise HTTPException(404, "任务不存在")
+    geometry_data = task_data.get("geometry_data")
+    if not geometry_data:
+        raise HTTPException(400, "该任务尚未完成几何分析")
+    from moldinsight.core.ai_parting_detector import AIPartingSurfaceDetectorV2
+    detector = AIPartingSurfaceDetectorV2(use_gnn=True)
+    result = detector._detect_with_geometry(None, geometry_data)
+    return {"status": "success", "data": result}
+
+
+@router.post("/detect-undercuts")
+async def detect_undercuts(
+    request: Request,
+    current_user: User = Depends(get_current_active_user),
+):
+    body = await request.json()
+    task_id = body.get("task_id")
+    parting_direction = body.get("parting_direction", [0, 0, 1])
+    mold_size = body.get("mold_size", {"length": 300, "width": 300, "height": 200})
+    if not task_id:
+        raise HTTPException(404, "缺少 task_id")
+    task_data = await _get_task_data(task_id)
+    if not task_data:
+        raise HTTPException(404, "任务不存在")
+    sd = _get_cached("side_action_designer")
+    if not sd:
+        raise HTTPException(503, "服务不可用：核心模块未加载")
+    result = sd.analyze_and_design(
+        shape=None, parting_direction=parting_direction, mold_size=mold_size,
+    )
+    return {"status": "success", "data": result}
+
+
+@router.post("/design-cam")
+async def design_mold_cam(
+    request: Request,
+    current_user: User = Depends(get_current_active_user),
+):
+    body = await request.json()
+    cavity_bbox = body.get("cavity_bbox", {"dimensions": [100, 100, 50], "min": [-50, -50, -25], "max": [50, 50, 25]})
+    stock_bbox = body.get("stock_bbox", {"dimensions": [150, 150, 100], "min": [-75, -75, -50], "max": [75, 75, 50]})
+    mold_steel = body.get("mold_steel", "P20")
+    surface_quality = body.get("surface_quality", "standard")
+    controller = body.get("controller", "fanuc")
+    cam = _get_cached("mold_cam_designer")
+    if not cam:
+        raise HTTPException(503, "服务不可用：核心模块未加载")
+    result = cam.design_mold_cam(
+        cavity_bbox=cavity_bbox, stock_bbox=stock_bbox,
+        mold_steel=mold_steel, surface_quality=surface_quality,
+        controller=controller,
+    )
+    return {"status": "success", "data": result}
+
+
+@router.post("/check-collision")
+async def check_toolpath_collision(
+    request: Request,
+    current_user: User = Depends(get_current_active_user),
+):
+    body = await request.json()
+    toolpath_points = body.get("toolpath_points", [[0, 0, 50], [10, 10, -5], [20, 20, -10]])
+    tool = body.get("tool", {"diameter": 10, "flute_length": 30, "shank_diameter": 10})
+    stock_bbox = body.get("stock_bbox", {"min": [-50, -50, -25], "max": [50, 50, 25]})
+    clamp_positions = body.get("clamp_positions")
+    cd = _get_cached("collision_detector")
+    if not cd:
+        raise HTTPException(503, "服务不可用：核心模块未加载")
+    result = cd.check_toolpath_safety(toolpath_points, tool, stock_bbox, clamp_positions)
+    return {"status": "success", "data": result}
+
+
+@router.post("/optimize-toolpath")
+async def optimize_toolpath(
+    request: Request,
+    current_user: User = Depends(get_current_active_user),
+):
+    body = await request.json()
+    toolpath_points = body.get("toolpath_points", [[0, 0, 50], [10, 10, -5], [20, 20, -10]])
+    cutting_params = body.get("cutting_params", {"feed_rate_mm_min": 500})
+    stock_bbox = body.get("stock_bbox")
+    to = _get_cached("toolpath_optimizer")
+    if not to:
+        raise HTTPException(503, "服务不可用：核心模块未加载")
+    result = to.optimize_toolpath(toolpath_points, cutting_params, stock_bbox)
+    return {"status": "success", "data": result}
+
+
+@router.post("/design-electrodes")
+async def design_edm_electrodes(
+    request: Request,
+    current_user: User = Depends(get_current_active_user),
+):
+    body = await request.json()
+    undercut_regions = body.get("undercut_regions", [{"center": [0, 0, 0], "area": 100, "type": "undercut"}])
+    cavity_bbox = body.get("cavity_bbox", {"dimensions": [100, 100, 50]})
+    material = body.get("material", "copper")
+    spark_gap = body.get("spark_gap", 0.05)
+    overburn = body.get("overburn", 0.1)
+    ed = _get_cached("edm_designer")
+    if not ed:
+        raise HTTPException(503, "服务不可用：核心模块未加载")
+    result = ed.design_electrodes(undercut_regions, cavity_bbox, material, spark_gap, overburn)
+    return {"status": "success", "data": result}
+
+
+@router.post("/simulate-machining")
+async def simulate_machining(
+    request: Request,
+    current_user: User = Depends(get_current_active_user),
+):
+    body = await request.json()
+    operations = body.get("operations", [{"strategy": "z_level_roughing", "levels": [{"z": -5}]}])
+    stock_bbox = body.get("stock_bbox", {"dimensions": [100, 100, 50], "min": [-50, -50, -25], "max": [50, 50, 25]})
+    resolution = body.get("resolution", 2.0)
+    ms = _get_cached("machining_simulator")
+    if not ms:
+        raise HTTPException(503, "服务不可用：核心模块未加载")
+    result = ms.simulate_machining(operations, stock_bbox, resolution)
+    return {"status": "success", "data": result}
+
+
+@router.post("/export-mold")
+async def export_mold_results(
+    request: Request,
+    current_user: User = Depends(get_current_active_user),
+    db_session: AsyncSession = Depends(get_db_session),
+):
+    body = await request.json()
+    task_id = body.get("task_id")
+    scheme_id = body.get("scheme_id")
+    formats = body.get("formats", ["step", "stl"])
+    components = body.get("components", ["cavity", "core"])
+
+    if not task_id:
+        raise HTTPException(404, "缺少 task_id")
+
+    await _ensure_task_access(db_session, task_id, current_user.id)
+    task_data = await TaskQueryService.get_task_view(db_session, task_id)
+    if not task_data:
+        raise HTTPException(404, "任务不存在")
+
+    resolved_scheme_id = scheme_id or task_data.get("best_scheme_id") or "default"
+    persisted_files = _select_persisted_files(
+        task_id=task_id,
+        task_data=task_data,
+        scheme_id=resolved_scheme_id,
+        formats=formats,
+        components=components,
+    )
+    if persisted_files:
+        return {
+            "status": "success",
+            "data": {
+                "base_filename": Path(task_data.get("filename", f"mold_{task_id}")).stem,
+                "task_id": task_id,
+                "scheme_id": resolved_scheme_id,
+                "files": persisted_files,
+                "errors": [],
+                "total_files": len(persisted_files),
+                "total_errors": 0,
+                "source": "persisted",
+            },
+        }
+
+    cavity_shapes = processing_service.get_export_shapes(
+        task_id,
+        resolved_scheme_id,
+    )
+    filename = task_data.get("filename", f"mold_{task_id}")
+
+    if not cavity_shapes:
+        raise HTTPException(
+            409,
+            "导出缓存已失效或任务尚未完成，请重新分析后再导出以保证方案一致性",
+        )
+
+    base_filename = Path(filename).stem
+    result = cad_exporter.export_mold_results(
+        cavity_data=cavity_shapes,
+        base_filename=base_filename,
+        formats=formats,
+        components=components,
+        task_id=task_id,
+        scheme_id=resolved_scheme_id,
+    )
+    result["files"] = _augment_export_files(task_id, result.get("files", []))
+    result["source"] = "generated"
+
+    merged_artifacts = _merge_export_artifacts(_get_export_artifacts(task_data), result)
+    await storage_service.update_task_parameters(
+        db_session,
+        task_id,
+        {"export_artifacts": merged_artifacts},
+    )
+    await redis_task_manager.update_task(task_id, {"export_artifacts": merged_artifacts})
+
+    return {"status": "success", "data": result}
+
+
+@router.get("/export-download/{filepath:path}")
+async def download_export_file(
+    filepath: str,
+    task_id: str,
+    current_user: User = Depends(get_current_active_user),
+    db_session: AsyncSession = Depends(get_db_session),
+):
+    from fastapi.responses import FileResponse
+
+    if not task_id:
+        raise HTTPException(400, "缺少 task_id")
+
+    await _ensure_task_access(db_session, task_id, current_user.id)
+    task_data = await TaskQueryService.get_task_view(db_session, task_id)
+    if not task_data:
+        raise HTTPException(404, "任务不存在")
+
+    allowed_paths = set()
+    artifacts = _get_export_artifacts(task_data)
+    for scheme in (artifacts.get("schemes") or {}).values():
+        for file in scheme.get("files", []):
+            relative_path = str(file.get("relative_path") or "").replace("\\", "/").strip("/")
+            if relative_path:
+                allowed_paths.add(relative_path)
+
+    normalized_path = str(filepath or "").replace("\\", "/").strip("/")
+    if normalized_path not in allowed_paths:
+        raise HTTPException(403, "该文件不在任务允许下载清单中")
+
+    full_path = os.path.join(cad_exporter.output_dir, normalized_path.replace("/", os.sep))
+    if not os.path.exists(full_path):
+        raise HTTPException(404, "文件不存在")
+    if not os.path.abspath(full_path).startswith(os.path.abspath(cad_exporter.output_dir)):
+        raise HTTPException(403, "禁止访问")
+    media_types = {
+        ".step": "application/step", ".stp": "application/step",
+        ".iges": "application/iges", ".igs": "application/iges",
+        ".stl": "model/stl", ".brep": "application/octet-stream",
+    }
+    ext = Path(full_path).suffix.lower()
+    media_type = media_types.get(ext, "application/octet-stream")
+    return FileResponse(full_path, media_type=media_type, filename=os.path.basename(full_path))
+
+
+@router.get("/export-recommendations")
+async def get_export_recommendations(
+    target: str = "ug",
+    current_user: User = Depends(get_current_active_user),
+):
+    result = cad_exporter.get_export_recommendations(target)
+    return {"status": "success", "data": result}
+
+

src/moldinsight/api/aluminum_price_routes.py

@@ -0,0 +1,21 @@
+"""
+铝金属价格API路由
+
+提供铝金属价格的当前报价和历史走势数据。
+路由前缀: /api/aluminum-price
+不需要认证，公开访问。
+"""
+from fastapi import APIRouter, Query
+from moldinsight.services.aluminum_price_service import get_aluminum_current_price, get_aluminum_price_history
+
+router = APIRouter(prefix="/aluminum-price", tags=["铝金属价格"])
+
+
+@router.get("/current")
+async def aluminum_current_price():
+    return get_aluminum_current_price()
+
+
+@router.get("/history")
+async def aluminum_price_history(days: int = Query(default=30, ge=7, le=365)):
+    return get_aluminum_price_history(days=days)

src/moldinsight/api/cam_router.py

@@ -0,0 +1,103 @@
+from fastapi import APIRouter, Depends, HTTPException, Request
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from datetime import datetime
+
+from shared.database.database import get_db_session
+from shared.models.database import User, ProcessingTask
+from shared.services.auth_service import get_current_active_user
+from moldinsight.services.cam_bundle_service import cam_bundle_service
+from moldinsight.services.task_query_service import TaskQueryService
+from shared.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+router = APIRouter()
+DEFAULT_CAM_PREFERENCES = {
+    "mold_steel": "P20",
+    "surface_quality": "standard",
+    "controller": "fanuc",
+    "include_gcode": False,
+}
+
+
+@router.post("/cam/plan")
+async def generate_cam_plan(
+    request: Request,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_current_active_user),
+):
+    """基于任务分模结果生成 CAM 准备包（MVP）。"""
+    _ = current_user
+    body = await request.json()
+    task_id = body.get("task_id")
+    scheme_id = body.get("scheme_id")
+
+    if not task_id:
+        raise HTTPException(status_code=400, detail="缺少 task_id")
+
+    task_result = await db_session.execute(
+        select(ProcessingTask).where(ProcessingTask.task_id == task_id)
+    )
+    processing_task = task_result.scalar_one_or_none()
+
+    persisted_preferences = {}
+    if processing_task and isinstance(processing_task.parameters, dict):
+        persisted_preferences = (
+            processing_task.parameters.get("cam_preferences", {}) or {}
+        )
+
+    mold_steel = body.get(
+        "mold_steel",
+        persisted_preferences.get("mold_steel", DEFAULT_CAM_PREFERENCES["mold_steel"]),
+    )
+    surface_quality = body.get(
+        "surface_quality",
+        persisted_preferences.get("surface_quality", DEFAULT_CAM_PREFERENCES["surface_quality"]),
+    )
+    controller = body.get(
+        "controller",
+        persisted_preferences.get("controller", DEFAULT_CAM_PREFERENCES["controller"]),
+    )
+    include_gcode = bool(
+        body.get(
+            "include_gcode",
+            persisted_preferences.get("include_gcode", DEFAULT_CAM_PREFERENCES["include_gcode"]),
+        )
+    )
+
+    task_view = await TaskQueryService.get_task_view(db_session, task_id)
+    if not task_view:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    if task_view.get("status") != "completed":
+        raise HTTPException(status_code=400, detail="任务尚未完成，无法生成CAM计划")
+
+    try:
+        data = cam_bundle_service.build_bundle(
+            task_view=task_view,
+            scheme_id=scheme_id,
+            mold_steel=mold_steel,
+            surface_quality=surface_quality,
+            controller=controller,
+            include_gcode=include_gcode,
+        )
+        cam_preferences = {
+            "mold_steel": mold_steel,
+            "surface_quality": surface_quality,
+            "controller": controller,
+            "include_gcode": include_gcode,
+        }
+        if processing_task:
+            parameters = processing_task.parameters if isinstance(processing_task.parameters, dict) else {}
+            parameters["cam_preferences"] = cam_preferences
+            parameters["cam_last_plan"] = {
+                "scheme_id": data.get("scheme_id"),
+                "generated_at": datetime.now().isoformat(),
+            }
+            processing_task.parameters = parameters
+            await db_session.commit()
+
+        return {"status": "success", "data": data, "cam_preferences": cam_preferences}
+    except Exception as exc:
+        logger.error(f"生成CAM准备包失败 task_id={task_id}: {exc}")
+        raise HTTPException(status_code=500, detail=f"生成CAM准备包失败: {exc}")

src/moldinsight/api/debug_router.py

@@ -0,0 +1,18 @@
+# api/v1/debug_router.py
+from fastapi import APIRouter
+
+from shared.services.redis_task_manager import redis_task_manager
+
+router = APIRouter()
+
+
+@router.get("/debug/tasks")
+@router.post("/debug/tasks")
+async def debug_tasks():
+    """调试接口：查看所有任务"""
+    all_tasks = await redis_task_manager.get_all_tasks()
+    return {
+        "total_tasks": len(all_tasks),
+        "tasks": all_tasks,
+        "redis_connected": redis_task_manager.is_connected
+    }

src/moldinsight/api/health_router.py

@@ -0,0 +1,18 @@
+# api/v1/health_router.py
+from fastapi import APIRouter
+
+from shared.services.redis_task_manager import redis_task_manager
+
+router = APIRouter()
+
+
+@router.get("/health")
+@router.post("/health")
+async def health():
+    task_count = await redis_task_manager.get_task_count()
+    return {
+        "status": "healthy",
+        "pythonocc": True,
+        "total_tasks": task_count,
+        "redis_connected": redis_task_manager.is_connected
+    }

src/moldinsight/api/history_router.py

@@ -0,0 +1,37 @@
+# api/v1/history_router.py
+from fastapi import APIRouter, Depends
+import urllib.parse
+
+from moldinsight.services.storage_integration_rustfs import StorageIntegrationService
+from shared.database.database import get_db_session
+from sqlalchemy.ext.asyncio import AsyncSession
+
+router = APIRouter()
+
+
+@router.get("/history")
+@router.post("/history")
+async def get_file_history(db_session: AsyncSession = Depends(get_db_session)):
+    """获取按文件名分组的文件历史记录（支持多上传）"""
+    storage_service = StorageIntegrationService()
+    file_groups = await storage_service.get_all_file_groups(db_session)
+
+    return {
+        "total_files": len(file_groups),
+        "files": file_groups
+    }
+
+
+@router.get("/history/{filename}")
+@router.post("/history/{filename}")
+async def get_file_records(filename: str, db_session: AsyncSession = Depends(get_db_session)):
+    """获取指定文件名的所有上传记录（支持多上传历史）"""
+    decoded_filename = urllib.parse.unquote(filename)
+
+    storage_service = StorageIntegrationService()
+    file_records = await storage_service.get_file_history_by_filename(
+        db_session,
+        decoded_filename
+    )
+
+    return file_records

src/moldinsight/api/task_router.py

@@ -0,0 +1,79 @@
+# api/v1/task_router.py
+from fastapi import APIRouter, HTTPException, Request, Depends
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from moldinsight.services.task_query_service import TaskQueryService
+from shared.database.database import get_db_session
+from shared.utils.logger import get_logger
+from shared.models.database import ProcessingTask, STPFile
+
+logger = get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.get("/status/{task_id}")
+@router.post("/status/{task_id}")
+async def get_status(task_id: str, db_session: AsyncSession = Depends(get_db_session)):
+    """
+    获取任务状态
+
+    优先返回内存中的任务信息；
+    如果内存中不存在，则从 PostgreSQL + RustFS 组装一个持久化的任务视图，
+    结构与内存任务保持尽量一致，便于前端集中展示总结性信息。
+    """
+    try:
+        task_view = await TaskQueryService.get_task_view(db_session, task_id)
+        if task_view is None:
+            raise HTTPException(404, "任务不存在")
+        return task_view
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"获取任务状态失败: {e}")
+        raise HTTPException(500, f"获取任务状态失败: {str(e)}")
+
+
+@router.get("/result/{task_id}")
+@router.post("/result/{task_id}")
+async def result_page(request: Request, task_id: str, db_session: AsyncSession = Depends(get_db_session)):
+    """结果详情页面"""
+    # 从数据库查询任务详情
+    result = await db_session.execute(
+        select(ProcessingTask, STPFile)
+        .join(STPFile, ProcessingTask.stp_file_id == STPFile.id)
+        .where(ProcessingTask.task_id == task_id)
+    )
+
+    task_record = result.first()
+
+    if not task_record:
+        raise HTTPException(404, "任务不存在")
+
+    task, stp_file = task_record
+
+    # 构建任务详情数据
+    task_data = {
+        "task_id": task.task_id,
+        "filename": stp_file.original_filename if stp_file else "",
+        "file_size": stp_file.file_size if stp_file else 0,
+        "status": task.status,
+        "progress": task.progress,
+        "current_step": task.current_step,
+        "created_at": task.created_time.isoformat() if task.created_time else "",
+        "completed_at": task.completed_time.isoformat() if task.completed_time else "",
+        "error": task.error_message if task.error_message else ""
+    }
+
+    from fastapi.templating import Jinja2Templates
+    import os
+    templates_dir = os.path.join(os.getcwd(), "templates")
+    templates = Jinja2Templates(directory=templates_dir)
+    return templates.TemplateResponse("result.html", {
+        "request": request,
+        "task": task_data,
+        "pythonocc_available": True,
+        "version": "3.0.0"
+    })

src/moldinsight/api/upload_router.py

@@ -0,0 +1,122 @@
+# api/v1/upload_router.py
+from fastapi import APIRouter, UploadFile, File, HTTPException, Depends, Form
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+from shared.models.schemas import ProcessingStatus, create_task_info
+from shared.utils.file_handler import FileHandler
+from moldinsight.services.storage_integration_rustfs import StorageIntegrationService
+from shared.services.redis_task_manager import redis_task_manager
+from shared.database.database import get_db_session
+from shared.utils.logger import get_logger
+from sqlalchemy.ext.asyncio import AsyncSession
+from shared.services.auth_service import get_current_active_user
+from shared.models.database import User
+
+try:
+    from celery_tasks import process_stp_task
+    _use_celery = True
+except ImportError:
+    process_stp_task = None
+    _use_celery = False
+
+logger = get_logger(__name__)
+
+router = APIRouter()
+
+file_handler = FileHandler()
+
+
+@router.post("/upload")
+async def upload_stp(
+    file: UploadFile = File(...),
+    material: str = Form(...),
+    draft_angle: float = Form(...),
+    shrinkage_rate: float = Form(...),
+    parting_precision: float = Form(...),
+    cavity_match: int = Form(...),
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_current_active_user)
+):
+    """上传STP文件并存储到数据库"""
+    process_params = {
+        "material": material,
+        "draft_angle": float(draft_angle),
+        "shrinkage_rate": float(shrinkage_rate),
+        "parting_precision": float(parting_precision),
+        "cavity_match": int(cavity_match),
+    }
+    logger.info(
+        f"[UPLOAD] 用户={current_user.username}(id={current_user.id}) "
+        f"文件={file.filename} 参数={process_params} "
+        f"大小={file.size if hasattr(file, 'size') else 'unknown'}"
+    )
+
+    if not file.filename.lower().endswith(('.stp', '.step')):
+        logger.warning(f"[UPLOAD] 拒绝: 不支持的文件类型 - {file.filename}")
+        raise HTTPException(400, "只支持STP/STEP文件")
+
+    task_id = str(uuid.uuid4())
+
+    try:
+        file_path, file_size, file_meta = await file_handler.save_uploaded_file(file)
+    except ValueError as exc:
+        logger.warning(f"[UPLOAD] 拒绝非法文件: {file.filename}, 原因={exc}")
+        raise HTTPException(400, str(exc)) from exc
+    logger.info(f"[UPLOAD] 文件已保存: {file_path} ({file_size} bytes), task_id={task_id}")
+
+    storage_service = StorageIntegrationService()
+
+    stp_file = await storage_service.save_stp_file(
+        session=db_session,
+        file_path=file_path,
+        original_filename=file_meta["safe_original_name"],
+        user_id=current_user.id
+    )
+    logger.info(f"[UPLOAD] STP文件已存入RustFS+PG: stp_file.id={stp_file.id}")
+
+    await storage_service.create_processing_task(
+        db_session,
+        task_id,
+        stp_file.id,
+        parameters=process_params,
+    )
+
+    task_info = create_task_info(
+        task_id=task_id,
+        status=ProcessingStatus.PROCESSING,
+        filename=file.filename,
+        file_path=str(file_path),
+        file_size=file_size,
+        upload_time=str(datetime.now())
+    )
+    task_info["material"] = material
+    task_info["parameters"] = process_params
+    task_info["file_hash"] = file_meta["sha256"]
+    await redis_task_manager.set_task(task_id, task_info)
+
+    if _use_celery:
+        process_stp_task.delay(task_id, str(file_path), stp_file.id, process_params)
+        logger.info(f"[UPLOAD] Celery 任务已调度: task_id={task_id}")
+    else:
+        import asyncio
+        from moldinsight.services.processing_service import processing_service
+        asyncio.create_task(processing_service.process_file_with_storage(
+            task_id, str(file_path), stp_file.id, process_params
+        ))
+        logger.info(f"[UPLOAD] 直接后台处理: task_id={task_id} (celery 未安装)")
+
+    return {
+        "task_id": task_id,
+        "status": "processing",
+        "message": "文件上传成功，开始处理并存储到数据库",
+        "file_info": {
+            "filename": file.filename,
+            "size": file_size,
+            "pythonocc_available": True,
+            "database_file_id": stp_file.id,
+            "sha256": file_meta["sha256"],
+        },
+        "parameters": process_params,
+    }