Merge remote-tracking branch 'origin/main'

# Conflicts:
#	src/api/routes.py
#	src/core/aluminum_foam_mold.py
#	src/core/geometry_analyzer.py
#	src/core/mold_generator.py

src/api/v1/__init__.py

@@ -0,0 +1 @@
+# api/v1/__init__.py

src/api/v1/debug_router.py

@@ -0,0 +1,18 @@
+# api/v1/debug_router.py
+from fastapi import APIRouter
+
+from 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/api/v1/health_router.py

@@ -0,0 +1,18 @@
+# api/v1/health_router.py
+from fastapi import APIRouter
+
+from 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/api/v1/history_router.py

@@ -0,0 +1,37 @@
+# api/v1/history_router.py
+from fastapi import APIRouter, Depends
+import urllib.parse
+
+from services.storage_integration_rustfs import StorageIntegrationService
+from 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/api/v1/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 services.task_query_service import TaskQueryService
+from database.database import get_db_session
+from utils.logger import get_logger
+from 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/api/v1/upload_router.py

@@ -0,0 +1,85 @@
+# api/v1/upload_router.py
+from fastapi import APIRouter, UploadFile, File, HTTPException, BackgroundTasks, Depends
+from typing import Optional
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+from models.schemas import ProcessingStatus, create_task_info
+from utils.file_handler import FileHandler
+from services.storage_integration_rustfs import StorageIntegrationService
+from services.redis_task_manager import redis_task_manager
+from database.database import get_db_session
+from utils.logger import get_logger
+from sqlalchemy.ext.asyncio import AsyncSession
+from services.auth_service import get_current_active_user
+from services.processing_service import processing_service
+from models.database import User
+
+logger = get_logger(__name__)
+
+router = APIRouter()
+
+file_handler = FileHandler()
+
+
+@router.post("/upload")
+async def upload_stp(
+    background_tasks: BackgroundTasks,
+    file: UploadFile = File(...),
+    material: Optional[str] = "ABS",
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_current_active_user)
+):
+    """上传STP文件并存储到数据库"""
+
+    if not file.filename.lower().endswith(('.stp', '.step')):
+        raise HTTPException(400, "只支持STP/STEP文件")
+
+    task_id = str(uuid.uuid4())
+
+    # 保存文件
+    file_path, file_size = await file_handler.save_uploaded_file(file)
+
+    # 创建存储集成服务实例
+    storage_service = StorageIntegrationService()
+
+    # 保存STP文件到RustFS + PostgreSQL
+    stp_file = await storage_service.save_stp_file(
+        session=db_session,
+        file_path=file_path,
+        original_filename=file.filename,
+        user_id=current_user.id
+    )
+
+    # 创建处理任务记录
+    await storage_service.create_processing_task(db_session, task_id, stp_file.id)
+
+    # 创建任务记录（存入 Redis）
+    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())
+    )
+    await redis_task_manager.set_task(task_id, task_info)
+
+    # 后台处理（使用独立数据库会话，避免请求会话关闭问题）
+    background_tasks.add_task(
+        processing_service.process_file_with_storage,
+        task_id, file_path, stp_file.id, material
+    )
+
+    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
+        }
+    }