BDMS 55: observation coverage & other updates

api/observation.py

@@ -14,23 +14,37 @@
 # limitations under the License.
 # ===============================================================================
 from datetime import datetime
-
-from fastapi import APIRouter, Query
-from fastapi_pagination.ext.sqlalchemy import paginate
-from sqlalchemy import select
-from starlette.status import HTTP_201_CREATED
+from fastapi import APIRouter, Query, Request
+from starlette.status import HTTP_200_OK, HTTP_201_CREATED, HTTP_204_NO_CONTENT
 
 from api.pagination import CustomPage
-from core.dependencies import session_dependency
-from db import Sample
-from db.observation import Observation
+from core.dependencies import (
+    session_dependency,
+    amp_admin_dependency,
+    admin_dependency,
+    amp_viewer_dependency,
+    viewer_dependency,
+)
+from db import Observation, adder
 from schemas.observation import (
     CreateGroundwaterLevelObservation,
     GroundwaterLevelObservationResponse,
     CreateWaterChemistryObservation,
+    WaterChemistryObservationResponse,
+    CreateGeothermalObservation,
+    GeothermalObservationResponse,
+    ObservationResponse,
+    UpdateGroundwaterLevelObservation,
+    UpdateWaterChemistryObservation,
+    UpdateGeothermalObservation,
+)
+from services.crud_helper import model_deleter
+from services.query_helper import simple_get_by_id
+from services.observation_helper import (
+    get_observations,
+    observation_model_patcher,
+    get_observation_of_an_observation_class_by_id,
 )
-from services.observation_helper import add_observation
-from services.query_helper import order_sort_filter
 
 router = APIRouter(prefix="/observation", tags=["observation"])
 
@@ -40,51 +54,96 @@
 def add_groundwater_level_observation(
     obs_data: CreateGroundwaterLevelObservation,
     session: session_dependency,
-):
+    user: amp_admin_dependency,
+) -> GroundwaterLevelObservationResponse:
     """
     Add a new groundwater observation to the database.
     """
-    return add_observation(session, obs_data)
+    return adder(session, Observation, obs_data, user=user)
 
 
 @router.post("/water-chemistry", status_code=HTTP_201_CREATED)
 def add_water_chemistry_observation(
     obs_data: CreateWaterChemistryObservation,
     session: session_dependency,
-):
+    user: amp_admin_dependency,
+) -> WaterChemistryObservationResponse:
     """
     Add a new water chemistry observation to the database.
     This endpoint is currently a placeholder and does not implement any functionality.
     """
-    return add_observation(session, obs_data)
+    return adder(session, Observation, obs_data, user=user)
 
 
-#
-# @router.post("/geothermal", status_code=HTTP_201_CREATED)
-# def add_geothermal_observation(
-#     obs_data: CreateGeothermalObservation | CreateGeothermalObservationDirect,
-#     session: session_dependency,
-# ):
-#     """
-#     Add a new geothermal observation to the database.
-#     This endpoint is currently a placeholder and does not implement any functionality.
-#     """
-#     if isinstance(obs_data, CreateGeothermalObservationDirect):
-#         return direct_adder(session, GeothermalObservation, obs_data)
-#     else:
-#         return adder(session, GeothermalObservation, obs_data)
+@router.post("/geothermal", status_code=HTTP_201_CREATED)
+def add_geothermal_observation(
+    obs_data: CreateGeothermalObservation,
+    session: session_dependency,
+    user: admin_dependency,
+) -> GeothermalObservationResponse:
+    """
+    Add a new geothermal observation to the database.
+    This endpoint is currently a placeholder and does not implement any functionality.
+    """
+    return adder(session, Observation, obs_data, user=user)
+
+
+# PATCH ========================================================================
+
+
+@router.patch("/groundwater-level/{observation_id}", status_code=HTTP_200_OK)
+def update_groundwater_level_observation(
+    observation_id: int,
+    obs_data: UpdateGroundwaterLevelObservation,
+    session: session_dependency,
+    user: amp_admin_dependency,
+    request: Request,
+) -> GroundwaterLevelObservationResponse:
+    """
+    Update an existing groundwater level observation in the database.
+    """
+    return observation_model_patcher(session, request, observation_id, obs_data, user)
+
+
+@router.patch("/water-chemistry/{observation_id}", status_code=HTTP_200_OK)
+def update_water_chemistry_observation(
+    observation_id: int,
+    obs_data: UpdateWaterChemistryObservation,
+    session: session_dependency,
+    user: amp_admin_dependency,
+    request: Request,
+) -> WaterChemistryObservationResponse:
+    """
+    Update an existing water chemistry observation in the database.
+    """
+    return observation_model_patcher(session, request, observation_id, obs_data, user)
+
+
+@router.patch("/geothermal/{observation_id}", status_code=HTTP_200_OK)
+def update_geothermal_observation(
+    observation_id: int,
+    obs_data: UpdateGeothermalObservation,
+    session: session_dependency,
+    user: admin_dependency,
+    request: Request,
+) -> GeothermalObservationResponse:
+    """
+    Update an existing geothermal observation in the database.
+    """
+    return observation_model_patcher(session, request, observation_id, obs_data, user)
 
 
 # ============= Get ==============================================
-@router.get(
-    "/groundwater-level",
-)
+
+
+@router.get("/groundwater-level", summary="Get groundwater level observations")
 def get_groundwater_level_observations(
+    request: Request,
     session: session_dependency,
+    user: amp_viewer_dependency,
     thing_id: int | None = None,
     sensor_id: int | None = None,
     sample_id: int | None = None,
-    polygon: str | None = None,
     start_time: datetime | None = None,
     end_time: datetime | None = None,
     sort: str | None = None,
@@ -94,27 +153,174 @@ def get_groundwater_level_observations(
     """
     Retrieve all groundwater level observations from the database.
     """
-    sql = select(Observation)
-    sql = sql.where(Observation.observed_property == "groundwater level")
-    if thing_id is not None:
-        sql = sql.join(Sample)
-        sql = sql.where(Sample.thing_id == thing_id)
-    if sample_id is not None:
-        sql = sql.where(Observation.sample_id == sample_id)
-    if sensor_id is not None:
-        sql = sql.where(Observation.sensor_id == sensor_id)
+    return get_observations(
+        request=request,
+        session=session,
+        thing_id=thing_id,
+        sensor_id=sensor_id,
+        sample_id=sample_id,
+        start_time=start_time,
+        end_time=end_time,
+        sort=sort,
+        order=order,
+        filter_=filter_,
+    )
+
+
+@router.get(
+    "/groundwater-level/{observation_id}",
+    summary="Get groundwater level observation by ID",
+)
+def get_groundwater_level_observation_by_id(
+    session: session_dependency,
+    request: Request,
+    user: amp_viewer_dependency,
+    observation_id: int,
+) -> GroundwaterLevelObservationResponse:
+    return get_observation_of_an_observation_class_by_id(
+        session=session,
+        request=request,
+        observation_id=observation_id,
+    )
+
+
+@router.get("/water-chemistry", summary="Get water chemistry observations")
+def get_water_chemistry_observations(
+    request: Request,
+    session: session_dependency,
+    user: amp_viewer_dependency,
+    thing_id: int | None = None,
+    sensor_id: int | None = None,
+    sample_id: int | None = None,
+    start_time: datetime | None = None,
+    end_time: datetime | None = None,
+    sort: str | None = None,
+    order: str | None = None,
+    filter_: str = Query(alias="filter", default=None),
+) -> CustomPage[WaterChemistryObservationResponse]:
+    """
+    Retrieve all water chemistry observations from the database.
+    """
+    return get_observations(
+        request=request,
+        session=session,
+        thing_id=thing_id,
+        sensor_id=sensor_id,
+        sample_id=sample_id,
+        start_time=start_time,
+        end_time=end_time,
+        sort=sort,
+        order=order,
+        filter_=filter_,
+    )
 
-    if start_time:
-        sql = sql.where(Observation.observation_datetime >= start_time)
-    if end_time:
-        sql = sql.where(Observation.observation_datetime <= end_time)
 
-    sql = order_sort_filter(sql, Observation, sort, order, filter_)
+@router.get(
+    "/water-chemistry/{observation_id}", summary="Get water chemistry observation by ID"
+)
+def get_water_chemistry_observation_by_id(
+    session: session_dependency,
+    request: Request,
+    user: amp_viewer_dependency,
+    observation_id: int,
+) -> WaterChemistryObservationResponse:
+    return get_observation_of_an_observation_class_by_id(
+        session=session,
+        request=request,
+        observation_id=observation_id,
+    )
 
-    if not order:
-        sql = sql.order_by(Observation.observation_datetime.desc())
 
-    return paginate(query=sql, conn=session)
+@router.get("/geothermal", summary="Get geothermal observations")
+def get_geothermal_observations(
+    request: Request,
+    session: session_dependency,
+    user: viewer_dependency,
+    thing_id: int | None = None,
+    sensor_id: int | None = None,
+    sample_id: int | None = None,
+    start_time: datetime | None = None,
+    end_time: datetime | None = None,
+    sort: str | None = None,
+    order: str | None = None,
+    filter_: str = Query(alias="filter", default=None),
+) -> CustomPage[GeothermalObservationResponse]:
+    """
+    Retrieve all geothermal observations from the database.
+    """
+    return get_observations(
+        request=request,
+        session=session,
+        thing_id=thing_id,
+        sensor_id=sensor_id,
+        sample_id=sample_id,
+        start_time=start_time,
+        end_time=end_time,
+        sort=sort,
+        order=order,
+        filter_=filter_,
+    )
+
+
+@router.get("/geothermal/{observation_id}", summary="Get geothermal observation by ID")
+def get_geothermal_observation_by_id(
+    session: session_dependency,
+    request: Request,
+    user: amp_viewer_dependency,
+    observation_id: int,
+) -> GeothermalObservationResponse:
+    return get_observation_of_an_observation_class_by_id(
+        session=session, request=request, observation_id=observation_id
+    )
+
+
+@router.get("", summary="Get all observations")
+def get_all_observations(
+    request: Request,
+    session: session_dependency,
+    user: amp_viewer_dependency,
+    thing_id: int | None = None,
+    sensor_id: int | None = None,
+    sample_id: int | None = None,
+    start_time: datetime | None = None,
+    end_time: datetime | None = None,
+    sort: str | None = None,
+    order: str | None = None,
+    filter_: str = Query(alias="filter", default=None),
+) -> CustomPage[ObservationResponse]:
+    return get_observations(
+        request=request,
+        session=session,
+        thing_id=thing_id,
+        sensor_id=sensor_id,
+        sample_id=sample_id,
+        start_time=start_time,
+        end_time=end_time,
+        sort=sort,
+        order=order,
+        filter_=filter_,
+    )
+
+
+@router.get("/{observation_id}", summary="Get an observation by its ID")
+def get_observation_by_id(
+    session: session_dependency, user: amp_viewer_dependency, observation_id: int
+) -> ObservationResponse:
+    return simple_get_by_id(session, Observation, observation_id)
+
+
+# DELETE =======================================================================
+
+
+@router.delete(
+    "/{observation_id}",
+    summary="Delete an observation",
+    status_code=HTTP_204_NO_CONTENT,
+)
+def delete_observation(
+    session: session_dependency, user: amp_admin_dependency, observation_id: int
+) -> None:
+    return model_deleter(session, Observation, observation_id)
 
 
 # ============= EOF =============================================

core/lexicon.json

@@ -11,10 +11,16 @@
   {"category": "unit", "term": "W/m²", "definition": "watts per square meter"},
   {"category": "unit", "term": "W/m·K", "definition": "watts per meter Kelvin"},
   {"category": "unit", "term": "m²/s", "definition": "square meters per second"},
+  {"category": "unit", "term": "deg C", "definition": "degree Celsius"},
+
+  {"category": "observed_property", "term": "groundwater level:groundwater level", "definition": "groundwater level measurement" },
+
+  {"category": "observed_property", "term": "geothermal:temperature", "definition": "Temperature measurement"},
+
+  {"category": "observed_property", "term": "water chemistry:pH", "definition": "pH"},
+  {"category": "observed_property", "term": "water chemistry:Alkalinity as CaCO3", "definition": "Alkalinity as CaCO3"},
+
 
-  {"category": "observed_property", "term": "groundwater level", "definition": "groundwater level measurement" },
-  {"category": "observed_property", "term": "pH", "definition": "pH"},
-  {"category": "observed_property", "term": "Alkalinity as CaCO3", "definition": "Alkalinity as CaCO3"},
 
   {"category": "release_status", "term": "draft", "definition": "draft version"},
   {"category": "release_status", "term": "provisional", "definition": "provisional version"},