553 lines
21 KiB
Python
553 lines
21 KiB
Python
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()
|
||
|
||
_cached_instances = {}
|
||
|
||
|
||
def _get_cached_import(key: str):
|
||
"""惰性导入核心模块，避免路由器模块级加载时的循环依赖。"""
|
||
if key in _cached_instances:
|
||
return _cached_instances[key]
|
||
try:
|
||
if key == "side_action_designer":
|
||
from moldinsight.core.side_action_designer import SideActionDesigner
|
||
instance = SideActionDesigner()
|
||
elif key == "cavity_layout_optimizer":
|
||
from moldinsight.core.cavity_layout_optimizer import CavityLayoutOptimizer
|
||
instance = CavityLayoutOptimizer()
|
||
elif key == "mold_system_designer":
|
||
from moldinsight.core.mold_system_designer import MoldSystemDesigner
|
||
instance = MoldSystemDesigner()
|
||
elif key == "mold_cam_designer":
|
||
from moldinsight.core.mold_cam import MoldCAMDesigner
|
||
instance = MoldCAMDesigner()
|
||
elif key == "collision_detector":
|
||
from moldinsight.core.mold_machining import CollisionDetector
|
||
instance = CollisionDetector()
|
||
elif key == "toolpath_optimizer":
|
||
from moldinsight.core.mold_machining import ToolpathOptimizer
|
||
instance = ToolpathOptimizer()
|
||
elif key == "edm_designer":
|
||
from moldinsight.core.mold_machining import EDMElectrodeDesigner
|
||
instance = EDMElectrodeDesigner()
|
||
elif key == "machining_simulator":
|
||
from moldinsight.core.mold_machining import MachiningSimulator
|
||
instance = MachiningSimulator()
|
||
else:
|
||
return None
|
||
_cached_instances[key] = instance
|
||
return instance
|
||
except Exception as e:
|
||
logger.warning(f"核心模块 {key} 加载失败: {e}")
|
||
return None
|
||
|
||
|
||
async def _get_task_data(task_id: str) -> dict:
|
||
return await redis_task_manager.get_task(task_id)
|
||
|
||
|
||
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_import("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_import("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("/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_import("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("/cost-estimate")
|
||
async def estimate_cost(
|
||
request: Request,
|
||
current_user: User = Depends(get_current_active_user),
|
||
):
|
||
"""LLM 模具成本估算（P2-2：真 AI 落地，需启用 LLM）"""
|
||
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, "任务不存在")
|
||
analysis_result = task_data.get("analysis_result")
|
||
if not analysis_result:
|
||
raise HTTPException(400, "该任务尚未完成分析")
|
||
detailed_context = {
|
||
"candidate_schemes": task_data.get("candidate_schemes", []),
|
||
"geometry_data": task_data.get("geometry_data", {}),
|
||
"metadata": {"selected_material": task_data.get("material")},
|
||
}
|
||
from moldinsight.services.llm_service import llm_service
|
||
result = await llm_service.estimate_cost(analysis_result, detailed_context)
|
||
if result is None:
|
||
raise HTTPException(503, "成本估算不可用（LLM 未启用或生成失败）")
|
||
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_import("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_import("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_import("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_import("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_import("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}
|
||
|
||
|