new endpoint for creating vector layers with geojson feature collections

Author: hancocb

backend/app/api/api_v1/endpoints/vector_layers.py

@@ -327,6 +327,86 @@ def download_vector_layer(
         )
 
 
+@router.post(
+    "/geojson",
+    response_model=schemas.vector_layer.VectorLayerFeatureCollection,
+    status_code=status.HTTP_201_CREATED,
+)
+def create_vector_layer_from_geojson(
+    vector_layer_in: schemas.vector_layer.VectorLayerCreate,
+    current_user: models.User = Depends(deps.get_current_approved_user),
+    project: models.Project = Depends(deps.can_read_write_project),
+    db: Session = Depends(deps.get_db),
+) -> Any:
+    """Create a vector layer from a GeoJSON FeatureCollection payload.
+
+    Args:
+        vector_layer_in: VectorLayerCreate schema with layer_name and geojson
+        current_user: Current authenticated user
+        project: Project the vector layer belongs to
+        db: Database session
+
+    Returns:
+        VectorLayerFeatureCollection: Created vector layer as a FeatureCollection with metadata
+
+    Raises:
+        HTTPException: If validation fails or layer creation fails
+    """
+    # Validate coordinates are within valid geographic ranges
+    validate_geojson_coordinates(vector_layer_in.geojson)
+
+    # Check that FeatureCollection has at least one feature
+    if not vector_layer_in.geojson.features or len(vector_layer_in.geojson.features) == 0:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="FeatureCollection must contain at least one feature",
+        )
+
+    # Convert FeatureCollection to GeoDataFrame
+    try:
+        gdf = feature_collection_to_geodataframe(vector_layer_in.geojson)
+    except Exception:
+        logger.exception("Failed to convert FeatureCollection to GeoDataFrame")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Unable to process GeoJSON FeatureCollection",
+        )
+
+    # Create vector layer records in database
+    try:
+        features = crud.vector_layer.create_with_project(
+            db,
+            file_name=vector_layer_in.layer_name,
+            gdf=gdf,
+            project_id=project.id,
+        )
+    except Exception:
+        logger.exception("Failed to create vector layer in database")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Unable to create vector layer",
+        )
+
+    # Build response with metadata
+    if len(features) > 0:
+        layer_id = features[0].properties.get("layer_id", "undefined")
+        feature_collection = {
+            "type": "FeatureCollection",
+            "features": features,
+            "metadata": {
+                "preview_url": f"{settings.API_DOMAIN}{settings.STATIC_DIR}"
+                f"/projects/{project.id}/vector/{layer_id}"
+                f"/preview.png",
+            },
+        }
+        return feature_collection
+    else:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="No features created",
+        )
+
+
 @router.delete("/{layer_id}", status_code=status.HTTP_200_OK)
 def delete_vector_layer(
     layer_id: str,
@@ -349,6 +429,69 @@ def delete_vector_layer(
         )
 
 
+def feature_collection_to_geodataframe(
+    geojson: schemas.vector_layer.FeatureCollection,
+) -> gpd.GeoDataFrame:
+    """
+    Converts a GeoJSON FeatureCollection to a GeoDataFrame.
+
+    Args:
+        geojson: The FeatureCollection to convert
+
+    Returns:
+        gpd.GeoDataFrame: GeoDataFrame with features from the FeatureCollection
+    """
+    return gpd.GeoDataFrame.from_features(geojson.features, crs="EPSG:4326")
+
+
+def validate_geojson_coordinates(geojson: schemas.vector_layer.FeatureCollection) -> None:
+    """
+    Validates that all coordinates in a GeoJSON FeatureCollection are within valid geographic ranges.
+    Raises HTTPException if invalid coordinates are found.
+
+    Args:
+        geojson: The FeatureCollection to validate
+
+    Raises:
+        HTTPException: If coordinates are outside valid geographic ranges
+    """
+    for i, feature in enumerate(geojson.features):
+        if hasattr(feature.geometry, "coordinates"):
+            # Handle different geometry types
+            if feature.geometry.type == "Point":
+                coords = [feature.geometry.coordinates]
+            elif feature.geometry.type in ["LineString", "MultiPoint"]:
+                coords = feature.geometry.coordinates
+            elif feature.geometry.type in ["Polygon", "MultiLineString"]:
+                # Flatten polygon/multilinestring coordinates
+                coords = []
+                for ring in feature.geometry.coordinates:
+                    coords.extend(ring)
+            elif feature.geometry.type == "MultiPolygon":
+                # Flatten multipolygon coordinates
+                coords = []
+                for polygon in feature.geometry.coordinates:
+                    for ring in polygon:
+                        coords.extend(ring)
+            else:
+                continue  # Skip unknown geometry types
+
+            # Validate each coordinate pair
+            for coord in coords:
+                if len(coord) >= 2:
+                    lng, lat = coord[0], coord[1]
+                    if not (-180 <= lng <= 180):
+                        raise HTTPException(
+                            status_code=status.HTTP_400_BAD_REQUEST,
+                            detail=f"Invalid longitude {lng} in feature {i}. Must be between -180 and 180.",
+                        )
+                    if not (-90 <= lat <= 90):
+                        raise HTTPException(
+                            status_code=status.HTTP_400_BAD_REQUEST,
+                            detail=f"Invalid latitude {lat} in feature {i}. Must be between -90 and 90.",
+                        )
+
+
 def get_preview_url(project_id: str, layer_id: str) -> str:
     """Returns URL for vector layer preview image.
 

backend/app/tests/api/api_v1/test_vector_layers.py

@@ -11,6 +11,7 @@
 from app.schemas.vector_layer import VectorLayerFeatureCollection
 from app.tests.utils.project import create_project
 from app.tests.utils.project_member import create_project_member
+from app.tests.utils.utils import get_geojson_feature_collection
 from app.tests.utils.vector_layers import create_feature_collection
 
 
@@ -340,3 +341,177 @@ def test_remove_vector_layer_without_project_role(
         f"{settings.API_V1_STR}/projects/{project.id}/vector_layers/{layer_id}"
     )
     assert response.status_code == status.HTTP_404_NOT_FOUND
+
+
+def test_create_vector_layer_from_geojson_with_point(
+    client: TestClient, db: Session, normal_user_access_token: str
+) -> None:
+    current_user = get_current_user(db, normal_user_access_token)
+    project = create_project(db, owner_id=current_user.id)
+    vector_layer_data = get_geojson_feature_collection("point")
+
+    response = client.post(
+        f"{settings.API_V1_STR}/projects/{project.id}/vector_layers/geojson",
+        json=vector_layer_data,
+    )
+    assert response.status_code == status.HTTP_201_CREATED
+    response_data = response.json()
+    assert response_data["type"] == "FeatureCollection"
+    assert len(response_data["features"]) == 1
+    assert response_data["features"][0]["geometry"]["type"] == "Point"
+    assert response_data["features"][0]["properties"]["layer_name"] == "Point Example"
+    assert "layer_id" in response_data["features"][0]["properties"]
+    assert "preview_url" in response_data["metadata"]
+
+
+def test_create_vector_layer_from_geojson_with_linestring(
+    client: TestClient, db: Session, normal_user_access_token: str
+) -> None:
+    current_user = get_current_user(db, normal_user_access_token)
+    project = create_project(db, owner_id=current_user.id)
+    vector_layer_data = get_geojson_feature_collection("linestring")
+
+    response = client.post(
+        f"{settings.API_V1_STR}/projects/{project.id}/vector_layers/geojson",
+        json=vector_layer_data,
+    )
+    assert response.status_code == status.HTTP_201_CREATED
+    response_data = response.json()
+    assert response_data["type"] == "FeatureCollection"
+    assert len(response_data["features"]) == 1
+    assert response_data["features"][0]["geometry"]["type"] == "LineString"
+    assert (
+        response_data["features"][0]["properties"]["layer_name"] == "Linestring Example"
+    )
+
+
+def test_create_vector_layer_from_geojson_with_polygon(
+    client: TestClient, db: Session, normal_user_access_token: str
+) -> None:
+    current_user = get_current_user(db, normal_user_access_token)
+    project = create_project(db, owner_id=current_user.id)
+    vector_layer_data = get_geojson_feature_collection("polygon")
+
+    response = client.post(
+        f"{settings.API_V1_STR}/projects/{project.id}/vector_layers/geojson",
+        json=vector_layer_data,
+    )
+    assert response.status_code == status.HTTP_201_CREATED
+    response_data = response.json()
+    assert response_data["type"] == "FeatureCollection"
+    assert len(response_data["features"]) == 1
+    assert response_data["features"][0]["geometry"]["type"] == "Polygon"
+    assert response_data["features"][0]["properties"]["layer_name"] == "Polygon Example"
+
+
+def test_create_vector_layer_from_geojson_with_multiple_features(
+    client: TestClient, db: Session, normal_user_access_token: str
+) -> None:
+    current_user = get_current_user(db, normal_user_access_token)
+    project = create_project(db, owner_id=current_user.id)
+    vector_layer_data = get_geojson_feature_collection("multipoint")
+
+    response = client.post(
+        f"{settings.API_V1_STR}/projects/{project.id}/vector_layers/geojson",
+        json=vector_layer_data,
+    )
+    assert response.status_code == status.HTTP_201_CREATED
+    response_data = response.json()
+    assert response_data["type"] == "FeatureCollection"
+    assert len(response_data["features"]) == 3
+    # All features should have the same layer_id
+    layer_id = response_data["features"][0]["properties"]["layer_id"]
+    for feature in response_data["features"]:
+        assert feature["properties"]["layer_id"] == layer_id
+
+
+def test_create_vector_layer_from_geojson_with_manager_role(
+    client: TestClient, db: Session, normal_user_access_token: str
+) -> None:
+    current_user = get_current_user(db, normal_user_access_token)
+    project = create_project(db)
+    create_project_member(
+        db, role=Role.MANAGER, member_id=current_user.id, project_id=project.id
+    )
+    vector_layer_data = get_geojson_feature_collection("point")
+
+    response = client.post(
+        f"{settings.API_V1_STR}/projects/{project.id}/vector_layers/geojson",
+        json=vector_layer_data,
+    )
+    assert response.status_code == status.HTTP_201_CREATED
+
+
+def test_create_vector_layer_from_geojson_with_viewer_role(
+    client: TestClient, db: Session, normal_user_access_token: str
+) -> None:
+    current_user = get_current_user(db, normal_user_access_token)
+    project = create_project(db)
+    create_project_member(
+        db, role=Role.VIEWER, member_id=current_user.id, project_id=project.id
+    )
+    vector_layer_data = get_geojson_feature_collection("point")
+
+    response = client.post(
+        f"{settings.API_V1_STR}/projects/{project.id}/vector_layers/geojson",
+        json=vector_layer_data,
+    )
+    assert response.status_code == status.HTTP_403_FORBIDDEN
+
+
+def test_create_vector_layer_from_geojson_without_project_role(
+    client: TestClient, db: Session, normal_user_access_token: str
+) -> None:
+    project = create_project(db)
+    vector_layer_data = get_geojson_feature_collection("point")
+
+    response = client.post(
+        f"{settings.API_V1_STR}/projects/{project.id}/vector_layers/geojson",
+        json=vector_layer_data,
+    )
+    assert response.status_code == status.HTTP_404_NOT_FOUND
+
+
+def test_create_vector_layer_from_geojson_with_invalid_longitude(
+    client: TestClient, db: Session, normal_user_access_token: str
+) -> None:
+    current_user = get_current_user(db, normal_user_access_token)
+    project = create_project(db, owner_id=current_user.id)
+    vector_layer_data = get_geojson_feature_collection("invalid_longitude")
+
+    response = client.post(
+        f"{settings.API_V1_STR}/projects/{project.id}/vector_layers/geojson",
+        json=vector_layer_data,
+    )
+    assert response.status_code == status.HTTP_400_BAD_REQUEST
+    assert "longitude" in response.json()["detail"].lower()
+
+
+def test_create_vector_layer_from_geojson_with_invalid_latitude(
+    client: TestClient, db: Session, normal_user_access_token: str
+) -> None:
+    current_user = get_current_user(db, normal_user_access_token)
+    project = create_project(db, owner_id=current_user.id)
+    vector_layer_data = get_geojson_feature_collection("invalid_latitude")
+
+    response = client.post(
+        f"{settings.API_V1_STR}/projects/{project.id}/vector_layers/geojson",
+        json=vector_layer_data,
+    )
+    assert response.status_code == status.HTTP_400_BAD_REQUEST
+    assert "latitude" in response.json()["detail"].lower()
+
+
+def test_create_vector_layer_from_geojson_with_empty_features(
+    client: TestClient, db: Session, normal_user_access_token: str
+) -> None:
+    current_user = get_current_user(db, normal_user_access_token)
+    project = create_project(db, owner_id=current_user.id)
+    vector_layer_data = get_geojson_feature_collection("empty_features")
+
+    response = client.post(
+        f"{settings.API_V1_STR}/projects/{project.id}/vector_layers/geojson",
+        json=vector_layer_data,
+    )
+    assert response.status_code == status.HTTP_400_BAD_REQUEST
+    assert "at least one feature" in response.json()["detail"].lower()

backend/app/tests/utils/utils.py

@@ -232,5 +232,51 @@ def get_geojson_feature_collection(
                 * 250001,
             ).model_dump(),
         }
+    elif geom_type.lower() == "invalid_longitude":
+        return {
+            "layer_name": "Invalid Longitude Example",
+            "geojson": FeatureCollection[Feature[Point, Dict[str, object]]](
+                type="FeatureCollection",
+                features=[
+                    Feature[Point, Dict[str, object]](
+                        type="Feature",
+                        geometry={
+                            "type": "Point",
+                            "coordinates": [200.0, 0.5],  # Invalid longitude
+                        },
+                        properties={
+                            "prop0": "value0",
+                        },
+                    )
+                ],
+            ).model_dump(),
+        }
+    elif geom_type.lower() == "invalid_latitude":
+        return {
+            "layer_name": "Invalid Latitude Example",
+            "geojson": FeatureCollection[Feature[Point, Dict[str, object]]](
+                type="FeatureCollection",
+                features=[
+                    Feature[Point, Dict[str, object]](
+                        type="Feature",
+                        geometry={
+                            "type": "Point",
+                            "coordinates": [102.0, 95.0],  # Invalid latitude
+                        },
+                        properties={
+                            "prop0": "value0",
+                        },
+                    )
+                ],
+            ).model_dump(),
+        }
+    elif geom_type.lower() == "empty_features":
+        return {
+            "layer_name": "Empty Features Example",
+            "geojson": FeatureCollection[Feature[Point, Dict[str, object]]](
+                type="FeatureCollection",
+                features=[],
+            ).model_dump(),
+        }
     else:
         raise ValueError(f"Unknown geometry type provided: {geom_type}")