Merge pull request #78 from DataIntegrationGroup/jir-transfer

BDMS-47 transfer

Author: jirhiker

api/observation.py

@@ -110,6 +110,10 @@ def get_groundwater_level_observations(
         sql = sql.where(Observation.observation_datetime <= end_time)
 
     sql = order_sort_filter(sql, Observation, sort, order, filter_)
+
+    if not order:
+        sql = sql.order_by(Observation.observation_datetime.desc())
+
     return paginate(query=sql, conn=session)
 
 

api/search.py

@@ -16,7 +16,11 @@
 from fastapi import APIRouter, Depends
 from sqlalchemy import select
 from sqlalchemy.orm import Session
+from api.pagination import CustomPage
+from fastapi_pagination import paginate
+from fastapi_pagination.utils import disable_installed_extensions_check
 
+from core.dependencies import session_dependency
 from db import (
     Contact,
     Email,
@@ -27,12 +31,13 @@
     AssetThingAssociation,
     search,
 )
-from db.engine import get_db_session
 
+
+disable_installed_extensions_check()
 router = APIRouter(prefix="/search", tags=["search"])
 
 
-def _get_contact_results(session: Session, q: str) -> list[dict]:
+def _get_contact_results(session: Session, q: str, limit: int) -> list[dict]:
     vector = (
         Contact.search_vector
         | Email.search_vector
@@ -41,7 +46,10 @@ def _get_contact_results(session: Session, q: str) -> list[dict]:
     )
 
     query = search(
-        select(Contact).join(Email).join(Phone).join(Address), q, vector=vector
+        select(Contact).join(Email).join(Phone).join(Address),
+        q,
+        vector=vector,
+        limit=limit,
     )
     contacts = session.scalars(query).all()
     results = [
@@ -62,31 +70,71 @@ def _get_contact_results(session: Session, q: str) -> list[dict]:
     return results
 
 
-def _get_thing_results(session: Session, q: str) -> list[dict]:
+def _get_thing_results(session: Session, q: str, limit: int) -> list[dict]:
     vector = Thing.search_vector
-    query = search(select(Thing), q, vector=vector)
+    water_well_query = search(
+        select(Thing).where(Thing.thing_type == "water well"),
+        q,
+        vector=vector,
+        limit=limit,
+    )
+    spring_well_query = search(
+        select(Thing).where(Thing.thing_type == "spring"), q, vector=vector, limit=limit
+    )
 
-    things = session.scalars(query).all()
-    results = [
-        {
-            "label": t.name,
-            "group": "Things",
-            "properties": {
-                "well_type": t.well_type,
-                "thing_type": t.thing_type,
-                "id": t.id,
-            },
+    wells = session.scalars(water_well_query).all()
+    springs = session.scalars(spring_well_query).all()
+
+    def _make_response(group: str, thing: Thing, properties: dict) -> dict:
+
+        if properties is None:
+            properties = {}
+
+        properties["thing_type"] = thing.thing_type
+        properties["id"] = thing.id
+        return {
+            "label": thing.name,
+            "group": group,
+            "properties": properties,
         }
-        for t in things
-    ]
 
-    return results
+    def make_well_response(thing: Thing) -> dict:
+        return _make_response(
+            "Wells",
+            thing,
+            {
+                "well_type": thing.well_type,
+                "well_depth": thing.well_depth,
+                "hole_depth": thing.hole_depth,
+            },
+        )
+
+    def make_spring_response(thing: Thing) -> dict:
+        return _make_response(
+            "Springs",
+            thing,
+            {
+                "spring_type": thing.spring_type,
+            },
+        )
+
+    return [
+        func(item)
+        for items, func in (
+            (wells, make_well_response),
+            (springs, make_spring_response),
+        )
+        for item in items
+    ]
 
 
-def _get_asset_results(session: Session, q: str) -> list[dict]:
+def _get_asset_results(session: Session, q: str, limit: int) -> list[dict]:
     vector = Asset.search_vector
     query = search(
-        select(Asset).join(AssetThingAssociation).join(Thing), q, vector=vector
+        select(Asset).join(AssetThingAssociation).join(Thing),
+        q,
+        vector=vector,
+        limit=limit,
     )
 
     assets = session.scalars(query).all()
@@ -109,16 +157,21 @@ def _get_asset_results(session: Session, q: str) -> list[dict]:
 
 
 @router.get("")
-def search_api(q: str, session: Session = Depends(get_db_session)):
+def search_api(
+    session: session_dependency,
+    q: str,
+    limit: int = 25,
+) -> CustomPage[dict]:
     """
     Search endpoint for the collaborative network.
     """
 
-    results = _get_contact_results(session, q)
-    results.extend(_get_thing_results(session, q))
-    results.extend(_get_asset_results(session, q))
+    results = _get_contact_results(session, q, limit)
+    results.extend(_get_thing_results(session, q, limit))
+    results.extend(_get_asset_results(session, q, limit))
 
-    return results
+    return paginate(results)
+    # return {"items": results, "total": len(results)}
 
 
 # ============= EOF =============================================