Add governed bathymetry profile workflow

2026-07-17 15:25:00 +02:00
parent c0cab9e3c5
commit 5b4e18059a
31 changed files with 1990 additions and 4 deletions
@@ -410,6 +410,126 @@ class DatasetService:

        return DatasetService._to_response(dataset)

+    @staticmethod
+    def import_vector_bytes(
+        db: Session,
+        *,
+        project_id: UUID,
+        filename: str,
+        content: bytes,
+        source: str,
+        source_name: str,
+        dataset_role: str,
+        reference_layer_name: str | None,
+        source_metadata: dict[str, Any],
+        provenance_metadata: dict[str, Any],
+        area_id: UUID | None = None,
+        temporal_series_key: str | None = None,
+        observed_at: datetime | None = None,
+        valid_from: datetime | None = None,
+        valid_to: datetime | None = None,
+        temporal_granularity: str | None = None,
+        source_version: str | None = None,
+        content_type: str = "application/geo+json",
+    ) -> DatasetCreateResponse:
+        if not db.get(Project, project_id):
+            raise AppError(code="PROJECT_NOT_FOUND", message="Project not found", status_code=404)
+        if area_id is not None:
+            area = db.get(Area, area_id)
+            if not area:
+                raise AppError(code="AREA_NOT_FOUND", message="Area not found", status_code=404)
+            if area.project_id != project_id:
+                raise AppError(code="INVALID_DATASET_SCOPE", message="Area does not belong to this project", status_code=400)
+        if not content:
+            raise AppError(code="INVALID_UPLOAD", message="Vector artifact is empty", status_code=400)
+        safe_filename = DatasetService._validate_upload_filename(filename)
+        if DatasetService._extension_for_path(safe_filename) not in DatasetService.VECTOR_EXTENSIONS:
+            raise AppError(code="INVALID_UPLOAD", message="Vector artifacts require .geojson or .json files", status_code=415)
+        normalized_role = DatasetService._normalize_dataset_role(dataset_role)
+        normalized_source_name = (source_name or "").strip() or ("manual" if normalized_role == "reference" else None)
+        temporal = DatasetService._validate_temporal_metadata(
+            temporal_series_key=temporal_series_key,
+            observed_at=observed_at,
+            valid_from=valid_from,
+            valid_to=valid_to,
+            temporal_granularity=temporal_granularity,
+            source_version=source_version,
+        )
+        try:
+            text = content.decode("utf-8")
+        except UnicodeDecodeError as exc:
+            raise AppError(code="INVALID_UPLOAD", message="Vector artifact must be UTF-8 encoded", status_code=400) from exc
+        try:
+            metadata = parse_geojson_payload(text)
+            vector_payload = json.loads(text)
+        except (ValueError, json.JSONDecodeError) as exc:
+            raise AppError(code="INVALID_GEOJSON", message=str(exc), status_code=400) from exc
+
+        dataset_id = uuid.uuid4()
+        storage_info = StorageService.persist_dataset_file(
+            project_id=str(project_id),
+            dataset_id=str(dataset_id),
+            dataset_type="vector",
+            original_filename=safe_filename,
+            content=content,
+            content_type=content_type,
+        )
+        dataset = Dataset(
+            id=dataset_id,
+            project_id=project_id,
+            area_id=area_id,
+            name=safe_filename,
+            dataset_type="vector",
+            source=source,
+            dataset_role=normalized_role,
+            source_name=normalized_source_name,
+            reference_layer_name=reference_layer_name if normalized_role == "reference" else None,
+            source_metadata=source_metadata,
+            provenance_metadata=provenance_metadata,
+            imported_at=datetime.now(timezone.utc),
+            **temporal,
+            storage_path=storage_info["storage_path"],
+            original_filename=storage_info["original_filename"],
+            stored_filename=storage_info["stored_filename"],
+            content_type=storage_info["content_type"],
+            size_bytes=storage_info["size_bytes"],
+            checksum_sha256=storage_info["checksum_sha256"],
+            crs=metadata.get("crs"),
+            bounds_json=metadata.get("bounds_json"),
+            metadata_json=metadata,
+            status="ready",
+        )
+        try:
+            db.add(dataset)
+            db.add(
+                DatasetVersion(
+                    dataset_id=dataset.id,
+                    version=1,
+                    storage_path=dataset.storage_path,
+                    source_version=dataset.source_version,
+                    observed_at=dataset.observed_at,
+                    valid_from=dataset.valid_from,
+                    valid_to=dataset.valid_to,
+                    checksum_sha256=dataset.checksum_sha256,
+                    source_metadata=dataset.source_metadata,
+                    provenance_metadata=dataset.provenance_metadata,
+                )
+            )
+            VectorFeatureService.persist_geojson_features(
+                db=db,
+                dataset_id=dataset.id,
+                payload=vector_payload,
+                feature_class=reference_layer_name if normalized_role == "reference" else None,
+                commit=False,
+            )
+            db.commit()
+            db.refresh(dataset)
+        except Exception:
+            db.rollback()
+            StorageService.remove_dataset_file(storage_info["storage_path"])
+            raise
+        return DatasetService._to_response(dataset)
+
    @staticmethod
    def import_raster_bytes(
        db: Session,