392 lines
14 KiB
Python
392 lines
14 KiB
Python
from __future__ import annotations
|
|
|
|
import logging
|
|
import shutil
|
|
from dataclasses import dataclass, field
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
from typing import Any, Callable, Literal
|
|
|
|
from sqlalchemy import select, update as sql_update
|
|
from sqlalchemy.orm import Session, joinedload
|
|
|
|
from app.config import settings as app_settings
|
|
from app.domains.media.models import MediaAsset, MediaAssetType
|
|
from app.domains.orders.models import Order, OrderLine, OrderStatus
|
|
from app.domains.products.models import CadFile, Product
|
|
from app.domains.rendering.models import GlobalRenderPosition, ProductRenderPosition, RenderTemplate
|
|
from app.services.material_service import resolve_material_map
|
|
from app.services.step_processor import build_part_colors
|
|
from app.services.template_service import (
|
|
get_material_library_path_for_session,
|
|
resolve_template_for_session,
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
EmitFn = Callable[..., None] | None
|
|
SetupStatus = Literal["ready", "skip", "failed", "missing"]
|
|
|
|
|
|
@dataclass(slots=True)
|
|
class OrderLineRenderSetupResult:
|
|
status: SetupStatus
|
|
order_line: OrderLine | None = None
|
|
order: Order | None = None
|
|
cad_file: CadFile | None = None
|
|
materials_source: list[dict[str, Any]] = field(default_factory=list)
|
|
usd_render_path: Path | None = None
|
|
glb_reuse_path: Path | None = None
|
|
part_colors: dict[str, str] = field(default_factory=dict)
|
|
render_start: datetime | None = None
|
|
reason: str | None = None
|
|
|
|
@property
|
|
def is_ready(self) -> bool:
|
|
return self.status == "ready" and self.order_line is not None and self.cad_file is not None
|
|
|
|
|
|
@dataclass(slots=True)
|
|
class RenderPositionContext:
|
|
rotation_x: float = 0.0
|
|
rotation_y: float = 0.0
|
|
rotation_z: float = 0.0
|
|
focal_length_mm: float | None = None
|
|
sensor_width_mm: float | None = None
|
|
source_name: str | None = None
|
|
source_kind: Literal["product", "global", "default"] = "default"
|
|
|
|
|
|
@dataclass(slots=True)
|
|
class TemplateResolutionResult:
|
|
template: RenderTemplate | None
|
|
material_library: str | None
|
|
material_map: dict[str, str] | None
|
|
use_materials: bool
|
|
override_material: str | None
|
|
category_key: str | None
|
|
output_type_id: str | None
|
|
|
|
|
|
def _emit(emit: EmitFn, order_line_id: str, message: str, level: str | None = None) -> None:
|
|
if emit is None:
|
|
return
|
|
if level is None:
|
|
emit(order_line_id, message)
|
|
else:
|
|
emit(order_line_id, message, level)
|
|
|
|
|
|
def _resolve_asset_path(storage_key: str | None) -> Path | None:
|
|
if not storage_key:
|
|
return None
|
|
candidate = Path(app_settings.upload_dir) / storage_key
|
|
if candidate.exists():
|
|
return candidate
|
|
return None
|
|
|
|
|
|
def prepare_order_line_render_context(
|
|
session: Session,
|
|
order_line_id: str,
|
|
*,
|
|
emit: EmitFn = None,
|
|
) -> OrderLineRenderSetupResult:
|
|
"""Load and validate the order line, then prepare reusable render inputs."""
|
|
_emit(emit, order_line_id, "Loading order line from database")
|
|
line = session.execute(
|
|
select(OrderLine)
|
|
.where(OrderLine.id == order_line_id)
|
|
.options(
|
|
joinedload(OrderLine.product).joinedload(Product.cad_file),
|
|
joinedload(OrderLine.output_type),
|
|
)
|
|
).scalar_one_or_none()
|
|
|
|
if line is None:
|
|
_emit(emit, order_line_id, "Order line not found in database", "error")
|
|
logger.error("OrderLine %s not found", order_line_id)
|
|
return OrderLineRenderSetupResult(status="missing", reason="order_line_not_found")
|
|
|
|
if line.render_status == "cancelled":
|
|
_emit(emit, order_line_id, "Order line already cancelled — skipping render")
|
|
logger.info("OrderLine %s cancelled — skipping", order_line_id)
|
|
return OrderLineRenderSetupResult(
|
|
status="skip",
|
|
order_line=line,
|
|
reason="line_cancelled",
|
|
)
|
|
|
|
order = session.execute(
|
|
select(Order).where(Order.id == line.order_id)
|
|
).scalar_one_or_none()
|
|
if order and order.status in (OrderStatus.rejected, OrderStatus.completed):
|
|
_emit(emit, order_line_id, f"Order {order.status.value} — skipping render")
|
|
logger.info("OrderLine %s: order %s — skipping", order_line_id, order.status.value)
|
|
if line.render_status in ("pending", "processing"):
|
|
session.execute(
|
|
sql_update(OrderLine)
|
|
.where(OrderLine.id == line.id)
|
|
.values(render_status="cancelled")
|
|
)
|
|
session.commit()
|
|
return OrderLineRenderSetupResult(
|
|
status="skip",
|
|
order_line=line,
|
|
order=order,
|
|
reason="order_closed",
|
|
)
|
|
|
|
if line.product is None or line.product.cad_file_id is None or line.product.cad_file is None:
|
|
_emit(emit, order_line_id, "Product has no CAD file — marking as failed", "error")
|
|
logger.warning("OrderLine %s: product has no CAD file", order_line_id)
|
|
session.execute(
|
|
sql_update(OrderLine)
|
|
.where(OrderLine.id == line.id)
|
|
.values(render_status="failed")
|
|
)
|
|
session.commit()
|
|
return OrderLineRenderSetupResult(
|
|
status="failed",
|
|
order_line=line,
|
|
order=order,
|
|
reason="missing_cad_file",
|
|
)
|
|
|
|
render_start = datetime.utcnow()
|
|
session.execute(
|
|
sql_update(OrderLine)
|
|
.where(OrderLine.id == line.id)
|
|
.values(
|
|
render_status="processing",
|
|
render_backend_used="celery",
|
|
render_started_at=render_start,
|
|
)
|
|
)
|
|
session.commit()
|
|
|
|
cad_file = line.product.cad_file
|
|
materials_source = line.product.cad_part_materials or []
|
|
|
|
usd_render_path = None
|
|
usd_asset = session.execute(
|
|
select(MediaAsset)
|
|
.where(
|
|
MediaAsset.cad_file_id == cad_file.id,
|
|
MediaAsset.asset_type == MediaAssetType.usd_master,
|
|
)
|
|
.order_by(MediaAsset.created_at.desc())
|
|
.limit(1)
|
|
).scalar_one_or_none()
|
|
if usd_asset:
|
|
usd_render_path = _resolve_asset_path(usd_asset.storage_key)
|
|
if usd_render_path:
|
|
logger.info(
|
|
"render_order_line: using usd_master %s for cad %s",
|
|
usd_render_path.name,
|
|
cad_file.id,
|
|
)
|
|
|
|
glb_reuse_path = None
|
|
if not usd_render_path:
|
|
glb_asset = session.execute(
|
|
select(MediaAsset)
|
|
.where(
|
|
MediaAsset.cad_file_id == cad_file.id,
|
|
MediaAsset.asset_type == MediaAssetType.gltf_geometry,
|
|
)
|
|
.order_by(MediaAsset.created_at.desc())
|
|
.limit(1)
|
|
).scalar_one_or_none()
|
|
glb_candidate = _resolve_asset_path(glb_asset.storage_key if glb_asset else None)
|
|
if glb_candidate and glb_candidate.stat().st_size > 0:
|
|
step_path = Path(cad_file.stored_path)
|
|
expected_glb = step_path.parent / f"{step_path.stem}_thumbnail.glb"
|
|
if not expected_glb.exists() or expected_glb.stat().st_size == 0:
|
|
try:
|
|
shutil.copy2(str(glb_candidate), str(expected_glb))
|
|
logger.info(
|
|
"render_order_line: reused gltf_geometry asset %s -> %s",
|
|
glb_candidate.name,
|
|
expected_glb.name,
|
|
)
|
|
glb_reuse_path = expected_glb
|
|
except Exception as copy_exc:
|
|
logger.warning("render_order_line: failed to copy GLB asset: %s", copy_exc)
|
|
else:
|
|
glb_reuse_path = expected_glb
|
|
|
|
if usd_render_path:
|
|
_emit(emit, order_line_id, "Using USD master for render (skipping GLB tessellation)")
|
|
elif glb_reuse_path:
|
|
_emit(
|
|
emit,
|
|
order_line_id,
|
|
f"Reusing cached GLB geometry ({glb_reuse_path.name}) — skipping re-tessellation",
|
|
)
|
|
else:
|
|
_emit(emit, order_line_id, "No USD master or cached GLB — will tessellate STEP -> GLB")
|
|
|
|
part_colors: dict[str, str] = {}
|
|
if cad_file.parsed_objects:
|
|
parsed_names = cad_file.parsed_objects.get("objects", [])
|
|
if materials_source:
|
|
part_colors = build_part_colors(parsed_names, materials_source)
|
|
|
|
return OrderLineRenderSetupResult(
|
|
status="ready",
|
|
order_line=line,
|
|
order=order,
|
|
cad_file=cad_file,
|
|
materials_source=materials_source,
|
|
usd_render_path=usd_render_path,
|
|
glb_reuse_path=glb_reuse_path,
|
|
part_colors=part_colors,
|
|
render_start=render_start,
|
|
)
|
|
|
|
|
|
def resolve_order_line_template_context(
|
|
session: Session,
|
|
setup: OrderLineRenderSetupResult,
|
|
*,
|
|
emit: EmitFn = None,
|
|
) -> TemplateResolutionResult:
|
|
"""Resolve render template, material library, and material map for a prepared order line."""
|
|
if not setup.is_ready:
|
|
raise ValueError("resolve_order_line_template_context requires a ready setup result")
|
|
|
|
line = setup.order_line
|
|
cad_file = setup.cad_file
|
|
assert line is not None
|
|
assert cad_file is not None
|
|
materials_source = setup.materials_source
|
|
category_key = line.product.category_key if line.product else None
|
|
output_type_id = str(line.output_type_id) if line.output_type_id else None
|
|
|
|
template = resolve_template_for_session(
|
|
session,
|
|
category_key=category_key,
|
|
output_type_id=output_type_id,
|
|
)
|
|
material_library = get_material_library_path_for_session(session)
|
|
|
|
material_map = None
|
|
use_materials = bool(material_library and materials_source)
|
|
if template and not template.material_replace_enabled:
|
|
use_materials = False
|
|
if use_materials:
|
|
material_map = {
|
|
material["part_name"]: material["material"]
|
|
for material in materials_source
|
|
if material.get("part_name") and material.get("material")
|
|
}
|
|
material_map = resolve_material_map(material_map)
|
|
|
|
line_override = getattr(line, "material_override", None)
|
|
output_override = line.output_type.material_override if line.output_type else None
|
|
override_material = line_override or output_override
|
|
if override_material:
|
|
override_keys = set(material_map.keys()) if material_map else set()
|
|
if cad_file and cad_file.parsed_objects:
|
|
for part_name in cad_file.parsed_objects.get("objects", []):
|
|
override_keys.add(part_name)
|
|
material_map = {key: override_material for key in override_keys}
|
|
use_materials = True
|
|
_emit(
|
|
emit,
|
|
str(line.id),
|
|
f"Material override active: {len(material_map)} parts → {override_material}",
|
|
)
|
|
|
|
if template:
|
|
_emit(
|
|
emit,
|
|
str(line.id),
|
|
"Using render template: "
|
|
f"{template.name} (collection={template.target_collection}, "
|
|
f"material_replace={template.material_replace_enabled}, "
|
|
f"lighting_only={template.lighting_only})",
|
|
)
|
|
logger.info(
|
|
"Render template resolved: '%s' path=%s, lighting_only=%s",
|
|
template.name,
|
|
template.blend_file_path,
|
|
template.lighting_only,
|
|
)
|
|
if not template:
|
|
_emit(emit, str(line.id), "No render template found — using factory settings (Mode A)")
|
|
logger.info(
|
|
"No render template for category_key=%r, output_type_id=%r",
|
|
category_key,
|
|
output_type_id,
|
|
)
|
|
|
|
return TemplateResolutionResult(
|
|
template=template,
|
|
material_library=material_library,
|
|
material_map=material_map,
|
|
use_materials=use_materials,
|
|
override_material=override_material,
|
|
category_key=category_key,
|
|
output_type_id=output_type_id,
|
|
)
|
|
|
|
|
|
def resolve_render_position_context(
|
|
session: Session,
|
|
line: OrderLine,
|
|
*,
|
|
emit: EmitFn = None,
|
|
) -> RenderPositionContext:
|
|
"""Resolve per-line render position values with product/global fallback."""
|
|
if line.render_position_id:
|
|
render_position = session.get(ProductRenderPosition, line.render_position_id)
|
|
if render_position:
|
|
_emit(
|
|
emit,
|
|
str(line.id),
|
|
f"Render position: '{render_position.name}' "
|
|
f"({render_position.rotation_x}°, {render_position.rotation_y}°, {render_position.rotation_z}°)"
|
|
+ (
|
|
f" focal_length={render_position.focal_length_mm}mm"
|
|
if render_position.focal_length_mm
|
|
else ""
|
|
),
|
|
)
|
|
return RenderPositionContext(
|
|
rotation_x=render_position.rotation_x,
|
|
rotation_y=render_position.rotation_y,
|
|
rotation_z=render_position.rotation_z,
|
|
focal_length_mm=render_position.focal_length_mm,
|
|
sensor_width_mm=render_position.sensor_width_mm,
|
|
source_name=render_position.name,
|
|
source_kind="product",
|
|
)
|
|
|
|
if line.global_render_position_id:
|
|
global_position = session.get(GlobalRenderPosition, line.global_render_position_id)
|
|
if global_position:
|
|
_emit(
|
|
emit,
|
|
str(line.id),
|
|
f"Global render position: '{global_position.name}' "
|
|
f"({global_position.rotation_x}°, {global_position.rotation_y}°, {global_position.rotation_z}°)"
|
|
+ (
|
|
f" focal_length={global_position.focal_length_mm}mm"
|
|
if global_position.focal_length_mm
|
|
else ""
|
|
),
|
|
)
|
|
return RenderPositionContext(
|
|
rotation_x=global_position.rotation_x,
|
|
rotation_y=global_position.rotation_y,
|
|
rotation_z=global_position.rotation_z,
|
|
focal_length_mm=global_position.focal_length_mm,
|
|
sensor_width_mm=global_position.sensor_width_mm,
|
|
source_name=global_position.name,
|
|
source_kind="global",
|
|
)
|
|
|
|
return RenderPositionContext()
|