NO TICKET: thing update and fix

api/search.py

@@ -81,8 +81,9 @@ def _get_thing_results(session: Session, q: str, limit: int) -> list[dict]:
         select(Thing).where(Thing.thing_type == "spring"), q, vector=vector, limit=limit
     )
 
-    wells = session.scalars(water_well_query).all()
-    springs = session.scalars(spring_well_query).all()
+    # unique needs to be called because of eager loads
+    wells = session.scalars(water_well_query).unique().all()
+    springs = session.scalars(spring_well_query).unique().all()
 
     def _make_response(group: str, thing: Thing, properties: dict) -> dict:
 

api/thing.py

@@ -62,7 +62,6 @@
     add_well_screen,
     get_db_things,
     get_thing_of_a_thing_type_by_id,
-    get_active_location,
 )
 from services.lexicon_helper import get_terms_by_category
 
@@ -328,7 +327,6 @@ async def get_thing_by_id(
     Retrieve a thing by ID from the database.
     """
     thing = simple_get_by_id(session, Thing, thing_id)
-    thing.active_location = get_active_location(session, thing)
     return thing
 
 

core/lexicon.json

@@ -20,9 +20,8 @@
     {"name": "participant_role", "description": null},
     {"name": "geochronology", "description": null},
     {"name": "horizontal_datum", "description": null},
-    {"name": "value_reason", "description": null},
-    {"name": "limit_type", "description": null},
     {"name": "groundwater_level_reason", "description": null},
+    {"name": "limit_type", "description": null},
     {"name": "measurement_method", "description": null},
     {"name": "monitoring_status", "description": null},
     {"name": "parameter_name", "description": null},

db/location.py

@@ -99,7 +99,9 @@ class LocationThingAssociation(Base, AutoBaseMixin):
     )
 
     # --- Relationship Definitions ---
-    location: Mapped["Location"] = relationship(back_populates="thing_associations")
+    location: Mapped["Location"] = relationship(
+        back_populates="thing_associations", lazy="joined"
+    )
     thing: Mapped["Thing"] = relationship(back_populates="location_associations")
 
 

db/thing.py

@@ -56,7 +56,7 @@ class Thing(Base, AutoBaseMixin, ReleaseMixin, StatusHistoryMixin, PermissionMix
     # TODO: what is the purpose of the `description` field? Is it ever used?
     # description: Mapped[str] = mapped_column(String(500), nullable=True)
     thing_type: Mapped[str] = lexicon_term(
-        nullable=True,
+        nullable=False,
         comment="A controlled vocabulary field defining the type of infrastructure (e.g., 'Well', 'Spring', 'Stream Gauge').",
     )
     first_visit_date: Mapped[Date] = mapped_column(
@@ -119,13 +119,52 @@ class Thing(Base, AutoBaseMixin, ReleaseMixin, StatusHistoryMixin, PermissionMix
 
     # One-To-Many: A Thing can be at many locations over time.
     # If the Thing is deleted, its location history will be deleted.
+    """
+    Developer's notes
+
+    If there are many location associations related to a thing, eagerly loading
+    the location associations may overburden the API and DB and introduce
+    performance issues. If this becomes an issue, active/current locations can 
+    be fetched in queries when retrieving things. Be thorough if following this
+    route as it will need to be included everywhere where a thing record is
+    needed, such as for GET /thing, GET /thing/{thing_id}, and GET /contact. See
+    below for an example of a way to retrieve the active/current location in a
+    query:
+
+    from sqlalchemy.orm import aliased
+    from sqlalchemy import select, func
+
+    LTA = aliased(LocationThingAssociation)
+    latest_assoc = (
+        select(
+            LTA.thing_id,
+            func.max(LTA.effective_start).label("max_start")
+        )
+        .where(LTA.effective_end == None)
+        .group_by(LTA.thing_id)
+        .subquery()
+    )
+
+    lta_alias = aliased(LocationThingAssociation)
+    query = (
+        select(Thing, Location)
+        .join(lta_alias, Thing.id == lta_alias.thing_id)
+        .join(Location, lta_alias.location_id == Location.id)
+        .join(
+            latest_assoc,
+            (latest_assoc.c.thing_id == lta_alias.thing_id) &
+            (latest_assoc.c.max_start == lta_alias.effective_start)
+        )
+    )
+    """
     location_associations = relationship(
         "LocationThingAssociation",
         back_populates="thing",
         overlaps="location",
         cascade="all, delete-orphan",
         passive_deletes=True,
         order_by="LocationThingAssociation.effective_start.desc()",
+        lazy="joined",
     )
 
     contact_associations = relationship(
@@ -199,6 +238,22 @@ class Thing(Base, AutoBaseMixin, ReleaseMixin, StatusHistoryMixin, PermissionMix
         )
     )
 
+    @property
+    def current_location(self):
+        """
+        Returns the currently active Location by sorting the effective_start
+        field. Thing eagerly loads location_association, which eagerly loads
+        location, which will hopefully prevent N+1 query problems.
+        """
+        current_location = sorted(
+            self.location_associations, key=lambda x: x.effective_start, reverse=True
+        )
+        return (
+            current_location[0].location
+            if current_location and current_location[0].effective_end is None
+            else None
+        )
+
 
 class ThingIdLink(Base, AutoBaseMixin, ReleaseMixin):
     """

schemas/thing.py

@@ -15,11 +15,46 @@
 # ===============================================================================
 from typing import List
 
-from pydantic import BaseModel, model_validator, PastDate
+from pydantic import BaseModel, model_validator, PastDate, Field
 
 from schemas import BaseCreateModel, BaseUpdateModel, BaseResponseModel
 from schemas.location import LocationResponse
 
+# -------- VALIDATE ----------
+
+
+class ValidateWell(BaseModel):
+    well_depth: float | None = None  # in feet
+    hole_depth: float | None = None  # in feet
+    well_casing_depth: float | None = None  # in feet
+
+    @model_validator(mode="after")
+    def check_depths(self):
+        if (
+            self.well_depth is not None
+            and self.hole_depth is not None
+            and self.well_depth > self.hole_depth
+        ):
+            raise ValueError("well depth must be less than than or equal to hole depth")
+        elif (
+            self.well_depth is not None
+            and self.well_casing_depth is not None
+            and self.well_casing_depth > self.well_depth
+        ):
+            raise ValueError(
+                "well casing depth must be greater than or equal to well depth"
+            )
+        elif (
+            self.hole_depth is not None
+            and self.well_casing_depth is not None
+            and self.well_casing_depth > self.hole_depth
+        ):
+            raise ValueError(
+                "well casing depth must be less than or equal to hole depth"
+            )
+
+        return self
+
 
 # -------- CREATE ----------
 class CreateThingIdLink(BaseModel):
@@ -43,21 +78,32 @@ class CreateBaseThing(BaseCreateModel):
     e.g. POST /thing/water-well, POST /thing/spring determines the thing_type
     """
 
-    location_id: int | None = None  # Optional location ID for the thing
+    location_id: int | None
     group_id: int | None = None  # Optional group ID for the thing
     name: str  # Name of the thing
     first_visit_date: PastDate  # Date of NMBGMR's first visit
 
 
-class CreateWell(CreateBaseThing):
+class CreateWell(CreateBaseThing, ValidateWell):
     """
     Schema for creating a well.
     """
 
     well_purpose: str | None = None
-    well_depth: float | None = None  # in feet
-    hole_depth: float | None = None  # in feet
+    well_depth: float | None = Field(
+        default=None, gt=0, description="Well depth in feet"
+    )
+    hole_depth: float | None = Field(
+        default=None, gt=0, description="Hole depth in feet"
+    )
     well_construction_notes: str | None = None
+    well_casing_diameter: float | None = Field(
+        default=None, gt=0, description="Well casing diameter in inches"
+    )
+    well_casing_depth: float | None = Field(
+        default=None, gt=0, description="Well casing depth in feet"
+    )
+    well_casing_material: str | None = None
 
 
 class CreateSpring(CreateBaseThing):
@@ -74,8 +120,8 @@ class CreateWellScreen(BaseCreateModel):
     """
 
     thing_id: int
-    screen_depth_bottom: float
-    screen_depth_top: float
+    screen_depth_bottom: float = Field(gt=0, description="Screen depth bottom in feet")
+    screen_depth_top: float = Field(gt=0, description="Screen depth top in feet")
     screen_type: str | None = None
     screen_description: str | None = None
 
@@ -93,24 +139,26 @@ def check_depths(self):
 class BaseThingResponse(BaseResponseModel):
     name: str
     thing_type: str
-    active_location: LocationResponse | None = None
-    first_visit_date: PastDate | None = None
+    current_location: LocationResponse | None
+    first_visit_date: PastDate | None
 
 
 class WellResponse(BaseThingResponse):
     """
     Response schema for well details.
     """
 
-    # api_id: str | None = None
-    # ose_pod_id: str | None = None
-    # usgs_id: str | None = None
-
     well_purpose: str | None = None  # e.g., "Production", "Observation", etc.
-    well_depth: float | None = None  # in feet
-    hole_depth: float | None = None  # in feet
+    well_depth: float | None = None
+    well_depth_unit: str = "ft"
+    hole_depth: float | None = None
+    hole_depth_unit: str = "ft"
+    well_casing_diameter: float | None = None  # in inches
+    well_casing_diameter_unit: str = "in"
+    well_casing_depth: float | None = None
+    well_casing_depth_unit: str = "ft"
+    well_casing_material: str | None = None
     well_construction_notes: str | None = None
-    # Additional fields can be added as needed
 
 
 class SpringResponse(BaseThingResponse):
@@ -149,7 +197,9 @@ class WellScreenResponse(BaseResponseModel):
     thing_id: int
     thing: WellResponse
     screen_depth_bottom: float
+    screen_depth_bottom_unit: str = "ft"
     screen_depth_top: float
+    screen_depth_top_unit: str = "ft"
     screen_type: str | None = None
     screen_description: str | None = None
 
@@ -197,12 +247,15 @@ class UpdateThing(BaseUpdateModel):
     first_visit_date: PastDate | None = None  # Date of NMBGMR's first visit
 
 
-class UpdateWell(UpdateThing):
+class UpdateWell(UpdateThing, ValidateWell):
 
     well_purpose: str | None = None
     well_depth: float | None = None  # in feet
     hole_depth: float | None = None  # in feet
     well_construction_notes: str | None = None
+    well_casing_diameter: float | None = None  # in inches
+    well_casing_depth: float | None = None  # in feet
+    well_casing_material: str | None = None
 
 
 class UpdateSpring(UpdateThing):

services/geospatial_helper.py

@@ -25,6 +25,8 @@
 from geoalchemy2.shape import to_shape
 from shapely.wkt import loads as wkt_loads
 from sqlalchemy import Select, select
+from sqlalchemy.orm import aliased
+from sqlalchemy import func
 
 
 def get_thing_features(
@@ -42,10 +44,30 @@ def get_thing_features(
     # elif thing_type == "spring":
     #     selection_args.append(SpringThing)
 
+    # Subquery: get the latest association for each thing (optionally only active)
+    lta_alias = aliased(LocationThingAssociation)
+
+    latest_assoc = (
+        select(
+            LocationThingAssociation.thing_id,
+            func.max(LocationThingAssociation.effective_start).label("max_start"),
+        )
+        .where(
+            LocationThingAssociation.effective_end == None
+        )  # Only active, remove if you want most recent regardless of end
+        .group_by(LocationThingAssociation.thing_id)
+        .subquery()
+    )
+
     sql = (
         select(Thing, ST_AsGeoJSON(Location.point).label("geojson"), Location.elevation)
-        .join(LocationThingAssociation, Thing.id == LocationThingAssociation.thing_id)
-        .join(Location, LocationThingAssociation.location_id == Location.id)
+        .join(lta_alias, Thing.id == lta_alias.thing_id)
+        .join(Location, lta_alias.location_id == Location.id)
+        .join(
+            latest_assoc,
+            (latest_assoc.c.thing_id == lta_alias.thing_id)
+            & (latest_assoc.c.max_start == lta_alias.effective_start),
+        )
     )
 
     if thing_type:
@@ -65,7 +87,8 @@ def get_thing_features(
         else:
             sql = sql.where(Group.id == group)
 
-    return session.execute(sql).all()
+    # unique needs to be invoked to prevent duplicates from eager loading
+    return session.execute(sql).unique().all()
 
 
 def create_shapefile(things: list, filename: str = "things.shp") -> None: