468 lines
15 KiB
Python
468 lines
15 KiB
Python
"""Asset management router."""
|
|
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
from typing import Optional
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Query
|
|
from sqlalchemy import select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.config import settings
|
|
from app.database import get_db
|
|
from app.dependencies import CurrentUser
|
|
from app.models.asset import Asset, AssetType
|
|
from app.models.world import World
|
|
from pydantic import BaseModel, Field
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
# --- Pydantic schemas ---
|
|
|
|
class AssetCreate(BaseModel):
|
|
"""Schema for creating an asset reference."""
|
|
name: str = Field(..., min_length=1, max_length=255)
|
|
description: Optional[str] = None
|
|
asset_type: AssetType
|
|
world_id: Optional[int] = None
|
|
|
|
|
|
class AssetResponse(BaseModel):
|
|
"""Schema for asset responses."""
|
|
id: int
|
|
name: str
|
|
description: Optional[str]
|
|
asset_type: AssetType
|
|
file_path: str
|
|
file_size: Optional[int]
|
|
mime_type: Optional[str]
|
|
world_id: Optional[int]
|
|
owner_id: int
|
|
is_public: bool
|
|
created_at: str
|
|
updated_at: str
|
|
|
|
model_config = {"from_attributes": True}
|
|
|
|
|
|
class AssetUpdate(BaseModel):
|
|
"""Schema for updating an asset."""
|
|
name: Optional[str] = None
|
|
description: Optional[str] = None
|
|
is_public: Optional[bool] = None
|
|
|
|
|
|
# --- Helpers ---
|
|
|
|
def _sanitize_filename(filename: str) -> str:
|
|
"""Strip path components and unsafe characters from a filename."""
|
|
# Remove any directory components (path traversal protection).
|
|
base = os.path.basename(filename.replace("\\", "/"))
|
|
# Keep only safe characters.
|
|
safe = "".join(c for c in base if c.isalnum() or c in "._-")
|
|
return safe or "file"
|
|
|
|
|
|
def _validate_gltf_json(content: bytes) -> dict:
|
|
"""Validate that content is a valid .gltf file (JSON-based glTF).
|
|
|
|
Returns the parsed JSON dict on success.
|
|
Raises ValueError if the file is not valid glTF.
|
|
"""
|
|
try:
|
|
data = json.loads(content)
|
|
except (json.JSONDecodeError, UnicodeDecodeError) as e:
|
|
raise ValueError(f"Invalid JSON in .gltf file: {e}")
|
|
|
|
if not isinstance(data, dict):
|
|
raise ValueError("glTF file root must be a JSON object")
|
|
|
|
if "asset" not in data:
|
|
raise ValueError("Missing required 'asset' property in glTF file")
|
|
|
|
if "scenes" not in data and "meshes" not in data and "nodes" not in data:
|
|
# glTF 2.0 spec: at least one of scenes, meshes, nodes, accessors,
|
|
# bufferViews, buffers, materials, textures, samplers, skin,
|
|
# animations, or extensions must be present.
|
|
# For simplicity, we require at least one of scenes/meshes/nodes.
|
|
raise ValueError(
|
|
"glTF file must contain at least one of: scenes, meshes, or nodes"
|
|
)
|
|
|
|
return data
|
|
|
|
|
|
def _validate_glb(content: bytes) -> dict:
|
|
"""Validate that content is a valid .glb file (binary glTF).
|
|
|
|
Returns the parsed JSON chunk data on success.
|
|
Raises ValueError if the file is not valid glTF.
|
|
"""
|
|
if len(content) < 12:
|
|
raise ValueError("glb file too short")
|
|
|
|
# Check magic bytes: must start with b'glTF'
|
|
magic = content[:4]
|
|
if magic != b"glTF":
|
|
raise ValueError(
|
|
f"Invalid glb magic bytes: expected b'glTF', got {magic!r}"
|
|
)
|
|
|
|
# Version check (we support version 2)
|
|
version = int.from_bytes(content[4:8], byteorder="little")
|
|
if version != 2:
|
|
raise ValueError(f"Unsupported glTF version: {version} (expected 2)")
|
|
|
|
# Total length check
|
|
total_length = int.from_bytes(content[8:12], byteorder="little")
|
|
if total_length != len(content):
|
|
raise ValueError(
|
|
f"glb total length mismatch: header says {total_length}, "
|
|
f"actual is {len(content)}"
|
|
)
|
|
|
|
# Parse JSON chunk
|
|
# Chunk format: length (4 bytes) + type (4 bytes) + data
|
|
offset = 12
|
|
json_chunk_data = None
|
|
|
|
while offset < len(content):
|
|
if offset + 8 > len(content):
|
|
raise ValueError("Incomplete chunk header in glb file")
|
|
|
|
chunk_length = int.from_bytes(content[offset:offset + 4], byteorder="little")
|
|
chunk_type = content[offset + 4:offset + 8]
|
|
|
|
if chunk_length + 8 > len(content) - offset:
|
|
raise ValueError("Chunk extends beyond file end")
|
|
|
|
if chunk_type == b"JSON":
|
|
json_chunk_data = content[offset + 8:offset + 8 + chunk_length]
|
|
# JSON chunk may have padding
|
|
break
|
|
elif chunk_type == b"BIN":
|
|
# Skip binary chunk
|
|
offset += 8 + chunk_length
|
|
continue
|
|
else:
|
|
# Unknown chunk type - skip it
|
|
offset += 8 + chunk_length
|
|
continue
|
|
|
|
if json_chunk_data is None:
|
|
raise ValueError("No JSON chunk found in glb file")
|
|
|
|
try:
|
|
data = json.loads(json_chunk_data)
|
|
except (json.JSONDecodeError, UnicodeDecodeError) as e:
|
|
raise ValueError(f"Invalid JSON in glb chunk: {e}")
|
|
|
|
if not isinstance(data, dict):
|
|
raise ValueError("glTF file root must be a JSON object")
|
|
|
|
if "asset" not in data:
|
|
raise ValueError("Missing required 'asset' property in glTF file")
|
|
|
|
return data
|
|
|
|
|
|
def _extract_metadata(data: dict) -> dict:
|
|
"""Extract metadata from parsed glTF data.
|
|
|
|
Returns a dict with:
|
|
- bounding_box: {"min": [...], "max": [...]} or null
|
|
- vertex_count: int
|
|
- material_count: int
|
|
- has_animation: bool
|
|
"""
|
|
metadata = {
|
|
"bounding_box": None,
|
|
"vertex_count": 0,
|
|
"material_count": 0,
|
|
"has_animation": False,
|
|
}
|
|
|
|
# Count materials
|
|
if "materials" in data and isinstance(data["materials"], list):
|
|
metadata["material_count"] = len(data["materials"])
|
|
|
|
# Check for animations
|
|
if "animations" in data and isinstance(data["animations"], list):
|
|
metadata["has_animation"] = len(data["animations"]) > 0
|
|
|
|
# Count vertices from meshes
|
|
vertex_count = 0
|
|
bounds_min = None
|
|
bounds_max = None
|
|
|
|
if "meshes" in data and isinstance(data["meshes"], list):
|
|
for mesh in data["meshes"]:
|
|
if "primitives" in mesh and isinstance(mesh["primitives"], list):
|
|
for primitive in mesh["primitives"]:
|
|
# Accessor index for positions
|
|
pos_accessor_idx = primitive.get("attributes", {}).get("POSITION")
|
|
if pos_accessor_idx is not None:
|
|
accessors = data.get("accessors", [])
|
|
if isinstance(accessors, list) and 0 <= pos_accessor_idx < len(accessors):
|
|
accessor = accessors[pos_accessor_idx]
|
|
count = accessor.get("count", 0)
|
|
vertex_count += count
|
|
|
|
# Extract bounding box from min/max
|
|
if "min" in accessor and "max" in accessor:
|
|
acc_min = accessor["min"]
|
|
acc_max = accessor["max"]
|
|
if bounds_min is None:
|
|
bounds_min = acc_min
|
|
bounds_max = acc_max
|
|
else:
|
|
bounds_min = [
|
|
min(a, b) for a, b in zip(bounds_min, acc_min)
|
|
]
|
|
bounds_max = [
|
|
max(a, b) for a, b in zip(bounds_max, acc_max)
|
|
]
|
|
|
|
metadata["vertex_count"] = vertex_count
|
|
|
|
if bounds_min is not None and bounds_max is not None:
|
|
metadata["bounding_box"] = {
|
|
"min": bounds_min,
|
|
"max": bounds_max,
|
|
}
|
|
|
|
return metadata
|
|
|
|
|
|
# --- Endpoints ---
|
|
|
|
@router.post("/", response_model=AssetResponse, status_code=201)
|
|
async def create_asset(
|
|
payload: AssetCreate,
|
|
current_user: CurrentUser,
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
"""Create a new asset reference."""
|
|
# Verify world ownership if world_id is provided
|
|
if payload.world_id is not None:
|
|
world = await db.get(World, payload.world_id)
|
|
if world is None:
|
|
raise HTTPException(status_code=404, detail="World not found")
|
|
if world.owner_id != current_user.id:
|
|
raise HTTPException(status_code=403, detail="Not owner of this world")
|
|
|
|
asset = Asset(
|
|
name=payload.name,
|
|
description=payload.description,
|
|
asset_type=payload.asset_type,
|
|
file_path="", # Will be set after upload
|
|
owner_id=current_user.id,
|
|
world_id=payload.world_id,
|
|
is_public=False,
|
|
)
|
|
db.add(asset)
|
|
await db.commit()
|
|
await db.refresh(asset)
|
|
return asset
|
|
|
|
|
|
@router.get("/", response_model=list[AssetResponse])
|
|
async def list_assets(
|
|
current_user: CurrentUser,
|
|
world_id: Optional[int] = Query(None, description="Filter by world"),
|
|
asset_type: Optional[AssetType] = Query(None),
|
|
limit: int = Query(50, ge=1, le=100),
|
|
offset: int = Query(0, ge=0),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
"""List assets with optional filters."""
|
|
stmt = select(Asset).where(Asset.owner_id == current_user.id)
|
|
|
|
if world_id is not None:
|
|
stmt = stmt.where(Asset.world_id == world_id)
|
|
if asset_type is not None:
|
|
stmt = stmt.where(Asset.asset_type == asset_type)
|
|
|
|
stmt = stmt.order_by(Asset.created_at.desc()).limit(limit).offset(offset)
|
|
result = await db.execute(stmt)
|
|
assets = result.scalars().all()
|
|
return assets
|
|
|
|
|
|
@router.get("/{asset_id}", response_model=AssetResponse)
|
|
async def get_asset(
|
|
asset_id: int,
|
|
current_user: CurrentUser,
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
"""Get a single asset by ID."""
|
|
asset = await db.get(Asset, asset_id)
|
|
if asset is None or asset.owner_id != current_user.id:
|
|
raise HTTPException(status_code=404, detail="Asset not found")
|
|
return asset
|
|
|
|
|
|
@router.patch("/{asset_id}", response_model=AssetResponse)
|
|
async def update_asset(
|
|
asset_id: int,
|
|
payload: AssetUpdate,
|
|
current_user: CurrentUser,
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
"""Update an asset."""
|
|
asset = await db.get(Asset, asset_id)
|
|
if asset is None or asset.owner_id != current_user.id:
|
|
raise HTTPException(status_code=404, detail="Asset not found")
|
|
|
|
update_data = payload.model_dump(exclude_unset=True)
|
|
for field, value in update_data.items():
|
|
setattr(asset, field, value)
|
|
|
|
await db.commit()
|
|
await db.refresh(asset)
|
|
return asset
|
|
|
|
|
|
@router.delete("/{asset_id}", status_code=204)
|
|
async def delete_asset(
|
|
asset_id: int,
|
|
current_user: CurrentUser,
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
"""Delete an asset."""
|
|
asset = await db.get(Asset, asset_id)
|
|
if asset is None or asset.owner_id != current_user.id:
|
|
raise HTTPException(status_code=404, detail="Asset not found")
|
|
|
|
await db.delete(asset)
|
|
await db.commit()
|
|
|
|
|
|
@router.post("/{asset_id}/upload", response_model=AssetResponse)
|
|
async def upload_asset_file(
|
|
asset_id: int,
|
|
current_user: CurrentUser,
|
|
file: UploadFile = File(...),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
"""Upload a file for an existing asset."""
|
|
asset = await db.get(Asset, asset_id)
|
|
if asset is None or asset.owner_id != current_user.id:
|
|
raise HTTPException(status_code=404, detail="Asset not found")
|
|
|
|
# Sanitize filename to prevent path traversal.
|
|
safe_filename = _sanitize_filename(file.filename or f"asset_{asset_id}")
|
|
|
|
# Validate file size against configured maximum.
|
|
max_bytes = settings.MAX_UPLOAD_SIZE_MB * 1024 * 1024
|
|
content = await file.read()
|
|
file_size = len(content)
|
|
if file_size > max_bytes:
|
|
raise HTTPException(
|
|
status_code=413,
|
|
detail=f"File size {file_size} exceeds maximum allowed size {max_bytes} bytes",
|
|
)
|
|
|
|
# Write the file to the upload directory.
|
|
upload_dir = Path(settings.UPLOAD_DIR)
|
|
upload_dir.mkdir(parents=True, exist_ok=True)
|
|
stored_name = f"{asset_id}_{safe_filename}"
|
|
file_path = upload_dir / stored_name
|
|
file_path.write_bytes(content)
|
|
|
|
asset.file_path = str(file_path)
|
|
asset.mime_type = file.content_type
|
|
asset.file_size = file_size
|
|
|
|
await db.commit()
|
|
await db.refresh(asset)
|
|
return asset
|
|
|
|
|
|
@router.post("/import-gltf", response_model=AssetResponse, status_code=201)
|
|
async def import_gltf(
|
|
current_user: CurrentUser,
|
|
file: UploadFile = File(...),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
"""Import a glTF or glb file as an asset.
|
|
|
|
Accepts a .gltf or .glb file, validates it, extracts metadata
|
|
(bounding box, vertex count, material count, animation flag),
|
|
stores the file, and returns an AssetResponse with the new asset's ID.
|
|
"""
|
|
filename = file.filename or ""
|
|
lower_filename = filename.lower()
|
|
|
|
# Validate file extension
|
|
if not (lower_filename.endswith(".gltf") or lower_filename.endswith(".glb")):
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail="File must be a .gltf or .glb file",
|
|
)
|
|
|
|
# Validate file size against configured maximum.
|
|
max_bytes = settings.MAX_UPLOAD_SIZE_MB * 1024 * 1024
|
|
content = await file.read()
|
|
file_size = len(content)
|
|
if file_size > max_bytes:
|
|
raise HTTPException(
|
|
status_code=413,
|
|
detail=f"File size {file_size} exceeds maximum allowed size {max_bytes} bytes",
|
|
)
|
|
|
|
# Validate file content based on format
|
|
try:
|
|
if lower_filename.endswith(".gltf"):
|
|
gltf_data = _validate_gltf_json(content)
|
|
else:
|
|
gltf_data = _validate_glb(content)
|
|
except ValueError as e:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"Invalid glTF file: {e}",
|
|
)
|
|
|
|
# Extract metadata
|
|
metadata = _extract_metadata(gltf_data)
|
|
|
|
# Create the asset record
|
|
asset = Asset(
|
|
name=Path(filename).stem,
|
|
description=None,
|
|
asset_type=AssetType.MODEL_GLTF,
|
|
file_path="", # Will be set after file storage
|
|
owner_id=current_user.id,
|
|
world_id=None,
|
|
is_public=False,
|
|
)
|
|
db.add(asset)
|
|
await db.commit()
|
|
await db.refresh(asset)
|
|
|
|
# Sanitize filename for storage.
|
|
# The original extension was validated above, so we keep exactly one
|
|
# extension after the sanitized stem.
|
|
original_stem = Path(filename).stem
|
|
safe_stem = _sanitize_filename(original_stem)
|
|
extension = ".gltf" if lower_filename.endswith(".gltf") else ".glb"
|
|
stored_name = f"{asset.id}_{safe_stem}{extension}"
|
|
|
|
# Write the file to the upload directory
|
|
upload_dir = Path(settings.UPLOAD_DIR)
|
|
upload_dir.mkdir(parents=True, exist_ok=True)
|
|
file_path = upload_dir / stored_name
|
|
file_path.write_bytes(content)
|
|
|
|
# Update asset with file info and metadata
|
|
asset.file_path = str(file_path)
|
|
asset.file_size = file_size
|
|
asset.mime_type = "model/gltf+json" if lower_filename.endswith(".gltf") else "model/gltf+binary"
|
|
asset.metadata_json = json.dumps(metadata)
|
|
|
|
await db.commit()
|
|
await db.refresh(asset)
|
|
return asset
|