263 lines
8.0 KiB
Python
263 lines
8.0 KiB
Python
"""Asset management router."""
|
|
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
from datetime import datetime
|
|
from typing import Optional, Union
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Query
|
|
from fastapi.responses import FileResponse
|
|
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 app.services import gltf as gltf_service
|
|
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: Union[datetime, str]
|
|
updated_at: Union[datetime, 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 _detect_asset_type(filename: Optional[str], content: bytes) -> AssetType:
|
|
"""Detect the asset type from filename and content."""
|
|
if filename and gltf_service.looks_like_gltf(content, filename):
|
|
return AssetType.MODEL_3D
|
|
# Fallback: let the caller decide based on mime_type or default.
|
|
return AssetType.OTHER
|
|
|
|
|
|
# --- 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}")
|
|
|
|
# Read the file content.
|
|
content = await file.read()
|
|
file_size = len(content)
|
|
|
|
# Determine which size limit to apply.
|
|
if gltf_service.looks_like_gltf(content, file.filename):
|
|
max_bytes = settings.GLTF_MAX_FILE_SIZE_MB * 1024 * 1024
|
|
else:
|
|
max_bytes = settings.MAX_UPLOAD_SIZE_MB * 1024 * 1024
|
|
|
|
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)
|
|
|
|
# Detect asset type from content/filename.
|
|
detected_type = _detect_asset_type(file.filename, content)
|
|
|
|
# Update asset record.
|
|
asset.file_path = str(file_path)
|
|
asset.mime_type = file.content_type
|
|
asset.file_size = file_size
|
|
|
|
# If this is a glTF file, extract and store metadata.
|
|
if detected_type == AssetType.MODEL_3D:
|
|
try:
|
|
metadata = gltf_service.extract_gltf_metadata(content)
|
|
asset.metadata_json = json.dumps(metadata)
|
|
# Also set the asset type to model_3d if it was auto-detected.
|
|
if asset.asset_type == AssetType.OTHER:
|
|
asset.asset_type = AssetType.MODEL_3D
|
|
except ValueError as exc:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"Invalid glTF file: {exc}",
|
|
)
|
|
|
|
await db.commit()
|
|
await db.refresh(asset)
|
|
return asset
|
|
|
|
|
|
@router.get("/{asset_id}/file")
|
|
async def get_asset_file(
|
|
asset_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
"""Download an asset binary file."""
|
|
asset = await db.get(Asset, asset_id)
|
|
if asset is None or not asset.file_path or not os.path.exists(asset.file_path):
|
|
raise HTTPException(status_code=404, detail="Asset file not found")
|
|
return FileResponse(
|
|
asset.file_path,
|
|
media_type=asset.mime_type or "application/octet-stream",
|
|
filename=os.path.basename(asset.file_path),
|
|
)
|
|
|