create a table to store bad and new geoms

src/backend/app/db/enums.py

@@ -251,3 +251,10 @@ class XLSFormType(StrEnum, Enum):
     # religious = "religious"
     # landusage = "landusage"
     # waterways = "waterways"
+
+
+class GeomStatus(StrEnum, Enum):
+    """Geometry status."""
+
+    NEW = "NEW"
+    BAD = "BAD"

src/backend/app/db/models.py

@@ -43,6 +43,7 @@
     BackgroundTaskStatus,
     CommunityType,
     EntityState,
+    GeomStatus,
     HTTPStatus,
     MappingLevel,
     MappingState,
@@ -70,6 +71,7 @@
         BackgroundTaskUpdate,
         BasemapIn,
         BasemapUpdate,
+        GeometryLogIn,
         ProjectIn,
         ProjectUpdate,
     )
@@ -1741,3 +1743,62 @@ def slugify(name: Optional[str]) -> Optional[str]:
     # Remove consecutive hyphens
     slug = sub(r"[-\s]+", "-", slug)
     return slug
+
+
+class DbGeometryLog(BaseModel):
+    """Table geometry log."""
+
+    geom: dict
+    status: GeomStatus
+    project_id: Optional[int]
+    task_id: Optional[int]
+
+    @classmethod
+    async def create(
+        cls,
+        db: Connection,
+        geometry_log_in: "GeometryLogIn",
+    ) -> Self:
+        """Creates a new geometry log with its status."""
+        model_dump = dump_and_check_model(geometry_log_in)
+        columns = []
+        value_placeholders = []
+
+        for key in model_dump.keys():
+            columns.append(key)
+            if key == "geom":
+                value_placeholders.append(f"ST_GeomFromGeoJSON(%({key})s)")
+                # Must be string json for db input
+                model_dump[key] = json.dumps(model_dump[key])
+            else:
+                value_placeholders.append(f"%({key})s")
+        async with db.cursor(row_factory=class_row(cls)) as cur:
+            await cur.execute(
+                f"""
+                INSERT INTO geometrylog
+                    ({", ".join(columns)})
+                VALUES
+                    ({", ".join(value_placeholders)})
+                RETURNING
+                    *,
+                    ST_AsGeoJSON(geom)::jsonb AS geom;
+            """,
+                model_dump,
+            )
+            new_geomlog = await cur.fetchone()
+        return new_geomlog
+
+    @classmethod
+    async def delete(
+        cls,
+        db: Connection,
+        id: int,
+    ) -> bool:
+        """Delete a geometry."""
+        async with db.cursor() as cur:
+            await cur.execute(
+                """
+                DELETE FROM geometrylog WHERE id = %(id)s;
+            """,
+                {"id": id},
+            )

src/backend/app/projects/project_routes.py

@@ -61,6 +61,7 @@
 from app.db.models import (
     DbBackgroundTask,
     DbBasemap,
+    DbGeometryLog,
     DbOdkEntities,
     DbProject,
     DbTask,
@@ -1235,3 +1236,26 @@ async def download_task_boundaries(
     }
 
     return Response(content=out, headers=headers)
+
+
+@router.post("/{project_id}/geometries")
+async def create_geom_log(
+    geom_log: project_schemas.GeometryLogIn,
+    db: Annotated[Connection, Depends(db_conn)],
+):
+    """Creates a new entry in the geometries log table.
+
+    Returns:
+    geometries (DbGeometryLog): The created geometries log entry.
+
+    Raises:
+    HTTPException: If the geometries log creation fails.
+    """
+    geometries = await DbGeometryLog.create(db, geom_log)
+    if not geometries:
+        raise HTTPException(
+            status_code=HTTPStatus.CONFLICT,
+            detail="geometries log creation failed.",
+        )
+
+    return geometries

src/backend/app/projects/project_schemas.py

@@ -33,10 +33,7 @@
 
 from app.central.central_schemas import ODKCentralDecrypted, ODKCentralIn
 from app.config import decrypt_value, encrypt_value, settings
-from app.db.enums import (
-    BackgroundTaskStatus,
-    ProjectPriority,
-)
+from app.db.enums import BackgroundTaskStatus, GeomStatus, ProjectPriority
 from app.db.models import DbBackgroundTask, DbBasemap, DbProject, slugify
 from app.db.postgis_utils import (
     geojson_to_featcol,
@@ -46,6 +43,30 @@
 )
 
 
+class GeometryLogIn(BaseModel):
+    """Geometry log insert."""
+
+    status: GeomStatus
+    geom: dict
+    project_id: Optional[int]
+    task_id: Optional[int]
+
+    @field_validator("geom", mode="before")
+    @classmethod
+    def parse_input_geometry(
+        cls,
+        value: FeatureCollection | Feature | MultiPolygon | Polygon,
+    ) -> Optional[dict]:
+        """Parse any format geojson into featurecollection.
+
+        Return geometry only.
+        """
+        if value is None:
+            return None
+        featcol = geojson_to_featcol(value)
+        return featcol.get("features")[0].get("geometry")
+
+
 class ProjectInBase(DbProject):
     """Base model for project insert / update (validators)."""
 

src/backend/migrations/002-create-geometry-log.sql

@@ -0,0 +1,19 @@
+-- ## Migration to create a table to store new and bad geometries.
+
+-- Start a transaction
+
+BEGIN;
+
+CREATE TABLE geometrylog (
+    id SERIAL PRIMARY KEY,
+    geom GEOMETRY NOT NULL,
+    status geomstatus,
+    project_id int,
+    task_id int
+);
+
+-- Indexes for efficient querying
+CREATE INDEX idx_geometrylog ON geometrylog USING gist (geom);
+
+-- Commit the transaction
+COMMIT;

src/backend/migrations/revert/002-create-geometry-log.sql

@@ -0,0 +1,11 @@
+-- ## Migration to delete geometrylog table.
+
+-- Start a transaction
+
+BEGIN;
+
+DROP TABLE IF EXISTS geometrylog;
+
+-- Commit the transaction
+
+COMMIT;