Upgrade async GPU analysis and workbench UX

backend/app/api/routes/exports.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 from uuid import UUID
 
-from fastapi import APIRouter, Depends, Query
+from fastapi import APIRouter, Depends, Query, Request
 from fastapi.responses import FileResponse
 from sqlalchemy.orm import Session
 
+from app.api.guest_scope import assert_guest_project_scope, guest_project_scope
 from app.core.errors import AppError
 from app.db.session import get_db
 from app.schemas import Envelope
@@ -20,13 +21,30 @@ from app.schemas.export import (
     ReportExportRequest,
 )
 from app.services.export_service import ExportService
+from app.services.dataset_service import DatasetService
+from app.services.detection_service import DetectionService
+from app.services.segmentation_service import SegmentationService
 from app.utils.response import envelope
 
 router = APIRouter(prefix="/exports", tags=["exports"])
 
 
 @router.post("/geojson", response_model=Envelope[ExportCreateResponse])
-def export_geojson(payload: GeoJsonExportRequest, db: Session = Depends(get_db)):
+def export_geojson(
+    payload: GeoJsonExportRequest,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    if guest_project_scope(request) is not None:
+        if payload.export_kind in {"dataset", "vector_selection"} and payload.dataset_id is not None:
+            dataset = DatasetService.get_dataset(db, payload.dataset_id)
+            assert_guest_project_scope(request, dataset.project_id)
+        elif payload.export_kind == "detection_run" and payload.analysis_run_id is not None:
+            run = DetectionService.get_run(db, payload.analysis_run_id)
+            assert_guest_project_scope(request, run.project_id)
+        elif payload.export_kind == "segmentation_run" and payload.analysis_run_id is not None:
+            run = SegmentationService.get_run(db, payload.analysis_run_id)
+            assert_guest_project_scope(request, run.project_id)
     if payload.export_kind == "vector_selection" and payload.dataset_id is not None and payload.bbox is not None:
         return envelope(
             ExportService.export_vector_selection_geojson(
@@ -61,17 +79,32 @@ def export_geojson(payload: GeoJsonExportRequest, db: Session = Depends(get_db))
 
 
 @router.post("/metadata", response_model=Envelope[ExportCreateResponse])
-def export_project_metadata(payload: MetadataExportRequest, db: Session = Depends(get_db)):
+def export_project_metadata(
+    payload: MetadataExportRequest,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    assert_guest_project_scope(request, payload.project_id)
     return envelope(ExportService.export_project_metadata(db, payload.project_id, payload.name).model_dump(mode="json"))
 
 
 @router.post("/report", response_model=Envelope[ExportCreateResponse])
-def export_project_report(payload: ReportExportRequest, db: Session = Depends(get_db)):
+def export_project_report(
+    payload: ReportExportRequest,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    assert_guest_project_scope(request, payload.project_id)
     return envelope(ExportService.export_project_report(db, payload.project_id, payload.name).model_dump(mode="json"))
 
 
 @router.post("/map-result", response_model=Envelope[ExportCreateResponse])
-def export_map_result(payload: MapResultExportRequest, db: Session = Depends(get_db)):
+def export_map_result(
+    payload: MapResultExportRequest,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    assert_guest_project_scope(request, payload.project_id)
     return envelope(ExportService.export_map_result(db, payload).model_dump(mode="json"))
 
 
@@ -81,25 +114,35 @@ def export_map_result(payload: MapResultExportRequest, db: Session = Depends(get
 )
 def list_project_exports(
     project_id: UUID,
+    request: Request,
     limit: int = Query(default=50, ge=1, le=100),
     offset: int = Query(default=0, ge=0),
     db: Session = Depends(get_db),
 ):
+    assert_guest_project_scope(request, project_id)
     return envelope(ExportService.list_project_exports(db, project_id, limit=limit, offset=offset).model_dump(mode="json"))
 
 
 @router.get("/{export_id}", response_model=Envelope[ExportRead])
-def get_export(export_id: UUID, db: Session = Depends(get_db)):
-    return envelope(ExportService.get_export(db, export_id).model_dump(mode="json"))
+def get_export(export_id: UUID, request: Request, db: Session = Depends(get_db)):
+    export = ExportService.get_export(db, export_id)
+    assert_guest_project_scope(request, export.project_id)
+    return envelope(export.model_dump(mode="json"))
 
 
 @router.get("/{export_id}/download")
-def download_export(export_id: UUID, db: Session = Depends(get_db)):
+def download_export(export_id: UUID, request: Request, db: Session = Depends(get_db)):
+    if guest_project_scope(request) is not None:
+        export = ExportService.get_export(db, export_id)
+        assert_guest_project_scope(request, export.project_id)
     path = ExportService.get_export_download_path(db, export_id)
     media_type = "text/html" if path.suffix.lower() in {".html", ".htm"} else "application/json"
     return FileResponse(path, filename=path.name, media_type=media_type)
 
 
 @router.get("/{export_id}/content", response_model=Envelope[ExportContentResponse])
-def get_export_content(export_id: UUID, db: Session = Depends(get_db)):
+def get_export_content(export_id: UUID, request: Request, db: Session = Depends(get_db)):
+    if guest_project_scope(request) is not None:
+        export = ExportService.get_export(db, export_id)
+        assert_guest_project_scope(request, export.project_id)
     return envelope(ExportService.get_export_content(db, export_id).model_dump(mode="json"))