feat: provision regional Kempen buildings

2026-07-14 19:01:49 +02:00
parent 8586921ae6
commit 4b0c016df9
14 changed files with 1323 additions and 29 deletions
@@ -12,7 +12,7 @@ from fastapi import UploadFile
 from sqlalchemy.orm import Session

 from app.core.errors import AppError
-from app.models import Dataset, DatasetVersion, Project
+from app.models import Area, Dataset, DatasetVersion, Project
 from app.schemas.dataset import (
    DatasetCreateResponse,
    DatasetStorageResponse,
@@ -410,6 +410,136 @@ class DatasetService:

        return DatasetService._to_response(dataset)

+    @staticmethod
+    def import_partitioned_vector_artifact(
+        db: Session,
+        *,
+        project_id: UUID,
+        area_id: UUID,
+        artifact_path: str | Path,
+        partition_paths: list[str | Path],
+        original_filename: str,
+        source: str,
+        dataset_role: str,
+        source_name: str,
+        reference_layer_name: str | None,
+        metadata_json: dict[str, Any],
+        source_metadata: dict[str, Any],
+        provenance_metadata: dict[str, Any],
+        temporal_series_key: str,
+        observed_at: datetime,
+        temporal_granularity: str = "snapshot",
+        source_version: str | None = None,
+        batch_size: int = 1000,
+    ) -> DatasetCreateResponse:
+        if not db.get(Project, project_id):
+            raise AppError(code="PROJECT_NOT_FOUND", message="Project not found", status_code=404)
+        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 partition_paths:
+            raise AppError(
+                code="INVALID_GEOJSON_PARTITIONS",
+                message="At least one GeoJSON partition is required",
+                status_code=400,
+            )
+
+        filename = DatasetService._validate_upload_filename(original_filename)
+        if DatasetService._extension_for_path(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)
+        temporal = DatasetService._validate_temporal_metadata(
+            temporal_series_key=temporal_series_key,
+            observed_at=observed_at,
+            valid_from=observed_at,
+            valid_to=None,
+            temporal_granularity=temporal_granularity,
+            source_version=source_version,
+        )
+        metadata = dict(metadata_json)
+        expected_feature_count = int(metadata.get("feature_count") or 0)
+        if expected_feature_count <= 0:
+            raise AppError(
+                code="INVALID_GEOJSON_PARTITIONS",
+                message="Partition metadata must declare a positive feature_count",
+                status_code=400,
+            )
+
+        dataset_id = uuid.uuid4()
+        storage_info = StorageService.persist_dataset_file_from_path(
+            project_id=str(project_id),
+            dataset_id=str(dataset_id),
+            dataset_type="vector",
+            original_filename=filename,
+            source_path=artifact_path,
+            content_type="application/geo+json",
+        )
+        dataset = Dataset(
+            id=dataset_id,
+            project_id=project_id,
+            area_id=area_id,
+            name=filename,
+            dataset_type="vector",
+            source=source,
+            dataset_role=normalized_role,
+            source_name=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=str(metadata.get("crs") or "EPSG:4326"),
+            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,
+                    checksum_sha256=dataset.checksum_sha256,
+                    source_metadata=dataset.source_metadata,
+                    provenance_metadata=dataset.provenance_metadata,
+                )
+            )
+            persisted_count = VectorFeatureService.persist_geojson_partitions(
+                db,
+                dataset.id,
+                partition_paths,
+                feature_class=reference_layer_name if normalized_role == "reference" else None,
+                batch_size=batch_size,
+            )
+            if persisted_count != expected_feature_count:
+                raise AppError(
+                    code="PARTITION_FEATURE_COUNT_MISMATCH",
+                    message=(
+                        f"Regional artifact declares {expected_feature_count} features but "
+                        f"{persisted_count} queryable features were indexed"
+                    ),
+                    status_code=400,
+                )
+            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 refresh_metadata(db: Session, dataset_id: UUID) -> DatasetCreateResponse:
        dataset = DatasetService._get_dataset(db, dataset_id)