feat: refactor well inventory CSV processing for improved error handling and validation

Author: jirhiker

schemas/thing.py

@@ -35,6 +35,7 @@
 from schemas.notes import NoteResponse, CreateNote
 from schemas.permission_history import PermissionHistoryResponse
 
+
 # -------- VALIDATE ----------
 
 
@@ -124,47 +125,8 @@ class CreateBaseThing(BaseCreateModel):
     alternate_ids: list[CreateThingIdLink] | None = None
     monitoring_frequencies: list[CreateMonitoringFrequency] | None = None
 
-    @field_validator("alternate_ids", mode="before")
-    def use_dummy_values(cls, v):
-        """
-        When alternate IDs are provided they are assumed to be the same as
-        the thing being created. This gets handled in the function services/thing_helper.py::add_thing.
-        By using dummy values here we can avoid validation errors and then use the
-        thing's id when creating the actual links.
-        """
-        # In "before" mode `v` is the raw input, which may be None, a list of
-        # dicts, or already-parsed model instances (in some code paths).
-        if v is None:
-            return v
-
-        # Only process lists; for any other unexpected type, leave as-is and
-        # let normal validation handle errors if appropriate.
-        if not isinstance(v, list):
-            return v
-
-        for alternate_id in v:
-        normalized: list = []
-        for alternate_id in v:
-            # If we already have a Pydantic model instance, set the attribute if possible.
-            if isinstance(alternate_id, BaseModel):
-                if hasattr(alternate_id, "thing_id"):
-                    setattr(alternate_id, "thing_id", -1)
-                    normalized.append(alternate_id)
-                else:
-                    data = alternate_id.model_dump()
-                    data["thing_id"] = -1
-                    normalized.append(data)
-            # If it's a plain dict, add the dummy thing_id key.
-            elif isinstance(alternate_id, dict):
-                data = dict(alternate_id)
-                data["thing_id"] = -1
-                normalized.append(data)
-            else:
-                # For any unexpected type, leave as-is and let normal validation
-                # handle potential errors.
-                normalized.append(alternate_id)
 
-        return normalized
+class CreateWell(CreateBaseThing, ValidateWell):
     """
     Schema for creating a well.
     """

services/well_inventory_csv.py

@@ -133,50 +133,53 @@ def _import_well_inventory_csv(session: Session, text: str, user: str):
     else:
         models, validation_errors = _make_row_models(rows, session)
         if models and not validation_errors:
-            for project, items in groupby(
-                sorted(models, key=lambda x: x.project), key=lambda x: x.project
-            ):
-                # get project and add if does not exist
-                # BDMS-221 adds group_type
-                sql = select(Group).where(
-                    and_(Group.group_type == "Monitoring Plan", Group.name == project)
-                )
-                group = session.scalars(sql).one_or_none()
-                if not group:
-                    group = Group(name=project, group_type="Monitoring Plan")
-                    session.add(group)
-                    session.flush()
-
-                for model in items:
-                    try:
-                        added = _add_csv_row(session, group, model, user)
-                        if added:
-                            session.commit()
-                    except ValueError as e:
-                        validation_errors.append(
-                            {
-                                "row": model.well_name_point_id,
-                                "field": "Invalid value",
-                                "error": str(e),
-                            }
-                        )
-                        session.rollback()
-                        continue
-                    except DatabaseError as e:
-                        logging.error(
-                            f"Database error while importing row '{model.well_name_point_id}': {e}"
-                        )
-                        validation_errors.append(
-                            {
-                                "row": model.well_name_point_id,
-                                "field": "Database error",
-                                "error": "A database error occurred while importing this row.",
-                            }
+            current_row_id = None
+            try:
+                for project, items in groupby(
+                    sorted(models, key=lambda x: x.project), key=lambda x: x.project
+                ):
+                    # get project and add if does not exist
+                    # BDMS-221 adds group_type
+                    sql = select(Group).where(
+                        and_(
+                            Group.group_type == "Monitoring Plan", Group.name == project
                         )
-                        session.rollback()
-                        continue
-
-                    wells.append(added)
+                    )
+                    group = session.scalars(sql).one_or_none()
+                    if not group:
+                        group = Group(name=project, group_type="Monitoring Plan")
+                        session.add(group)
+                        session.flush()
+
+                    for model in items:
+                        current_row_id = model.well_name_point_id
+                        added = _add_csv_row(session, group, model, user)
+                        wells.append(added)
+            except ValueError as e:
+                validation_errors.append(
+                    {
+                        "row": current_row_id or "unknown",
+                        "field": "Invalid value",
+                        "error": str(e),
+                    }
+                )
+                session.rollback()
+                wells = []
+            except DatabaseError as e:
+                logging.error(
+                    f"Database error while importing row '{current_row_id or 'unknown'}': {e}"
+                )
+                validation_errors.append(
+                    {
+                        "row": current_row_id or "unknown",
+                        "field": "Database error",
+                        "error": "A database error occurred while importing this row.",
+                    }
+                )
+                session.rollback()
+                wells = []
+            else:
+                session.commit()
 
     rows_imported = len(wells)
     rows_processed = len(rows)