BDMS-31:Implement Location/Thing API endpoints in GeoDjangoPOC

README.md

@@ -58,7 +58,7 @@ You can replace `makemigrations`, `migrate`, etc. with any Django command as nee
   [http://localhost:8000/](http://localhost:8000/)
 
 - **API Docs:**  
-  [http://localhost:8000/api/docs/](http://localhost:8000/api/docs/)
+  [http://localhost:8000/api/docs](http://localhost:8000/api/docs)
 
 - **Sample Locations API Endpoint Example:**  
   [http://localhost:8000/api/samplelocations/](http://localhost:8000/api/samplelocations/)

docker-compose.yml

@@ -1,3 +1,5 @@
+version: '3.9'
+
 services:
   db:
     image: timescale/timescaledb-ha:pg17-all

geodjango/geodjango/api.py

@@ -1,5 +1,8 @@
-from ninja import NinjaAPI
+from ninja import NinjaAPI, Redoc
 
 api = NinjaAPI()
 
-api.add_router('/samplelocations/', 'samplelocations.api.router')
+api.add_router('/location', 'samplelocations.api.locations.router', tags=['locations'])
+# api.add_router('/wells', 'samplelocations.api.wells.router', tags=['wells'])
+# api.add_router('/contacts', 'samplelocations.api.contacts.router', tags=['contacts'])
+api.add_router('/thing', 'samplelocations.api.thing.router', tags=['things'])

geodjango/geodjango/urls.py

@@ -16,7 +16,7 @@
 """
 from django.contrib import admin
 from django.urls import path
-from .api import api
+from geodjango.api import api
 from samplelocations import views
 
 urlpatterns = [

geodjango/samplelocations/admin.py

@@ -3,7 +3,7 @@
 from django import forms
 from django.contrib.gis.admin import GISModelAdmin
 from django.contrib.gis.geos import Point
-from samplelocations.models import Location, Thing, WellThing, SpringThing, Location_Thing_Junction, Sensor, Datastream, Observation, \
+from samplelocations.models import Location, Thing, Location_Thing_Junction, Sensor, Datastream, Observation, \
     GroundwaterLevelObservation, Sample
 
 class LocationForm(forms.ModelForm):
@@ -29,14 +29,6 @@ class LocationAdmin(GISModelAdmin):
 class ThingAdmin(ModelAdmin):
     pass
 
-@admin.register(WellThing)
-class WellThingAdmin(ModelAdmin):
-    pass
-
-@admin.register(SpringThing)
-class SpringThingAdmin(ModelAdmin):
-    pass
-
 @admin.register(Location_Thing_Junction)
 class LocationThingJunctionAdmin(ModelAdmin):
     pass
@@ -61,6 +53,14 @@ class GroundwaterLevelObservationAdmin(ModelAdmin):
 class SampleAdmin(ModelAdmin):
     pass
 
+# @admin.register(WellThing)
+# class WellThingAdmin(ModelAdmin):
+#     pass
+
+# @admin.register(SpringThing)
+# class SpringThingAdmin(ModelAdmin):
+#     pass
+
 #admin.site.register(Lexicon)
 #admin.site.register(WellScreen)
 #admin.site.register(Equipment)

geodjango/samplelocations/api/contacts.py

@@ -0,0 +1,22 @@
+# from ninja import Router
+# from ..models import Well, Contact
+# from django.shortcuts import get_object_or_404
+
+# router = Router()
+
+# @router.post("")
+# def post_contact(
+#     request,
+#     well_id: int,
+#     name: str,
+#     email: str,
+#     phone: str = None
+# ):
+#     well = get_object_or_404(Well, id=well_id)
+#     contact = Contact.objects.create(name=name, email=email, phone=phone)
+#     # Create or update owner for the location if needed
+#     location = well.location
+#     owner = location.owner
+#     owner.contact = contact
+#     owner.save()
+#     return {"contact_id": contact.id, "owner_id": owner.id}

geodjango/samplelocations/api/locations.py

@@ -0,0 +1,38 @@
+from ninja import Router
+from samplelocations.models import Location
+from samplelocations.schemas import LocationSchema, NotFoundSchema
+from typing import List
+
+router = Router()   
+
+@router.get("")
+def get_locations(request) -> List[LocationSchema]:
+    """
+    List all sample locations.
+    """    
+    locations = Location.objects.all()
+
+    response = [
+        {
+            "location_id": location.location_id,
+            "coordinates": f"POINT({location.coordinate.x} {location.coordinate.y} {location.coordinate.z})",
+            "date_created": location.date_created.isoformat(),
+        }
+        for location in locations
+    ]
+
+    return response
+
+@router.get("/{location_id}", response={200: LocationSchema, 404: NotFoundSchema})
+def get_location_by_id(request, location_id: int):
+    locations = Location.objects.filter(location_id=location_id)
+    if not locations.exists():
+        return 404, {"detail": f"Location with location_id {location_id} not found"}
+
+    location = locations.first()
+    response = {
+        "location_id": location.location_id,
+        "coordinates": f"POINT({location.coordinate.x} {location.coordinate.y} {location.coordinate.z})",
+        "date_created": location.date_created.isoformat(),
+    }
+    return response

geodjango/samplelocations/api/thing.py

@@ -0,0 +1,93 @@
+from ninja import Router
+from samplelocations.models import Thing, Location, Location_Thing_Junction
+from samplelocations.schemas import FeatureCollection, NotFoundSchema, WellProperties, SpringProperties
+from django.contrib.gis.geos import Point
+from django.shortcuts import get_object_or_404
+from django.forms.models import model_to_dict
+from django.http import HttpResponse
+from typing import List, Tuple
+
+router = Router()
+
+def get_things(thing_id: int | None = None) -> List[Thing]:
+    """
+    Retrieve all things or a specific thing by ID.
+    """
+    if thing_id is None:
+        return Thing.objects.all()
+    else:
+        # If a specific thing ID is provided, return that thing:
+        return [Thing.objects.filter(thing_id__in=[thing_id]).first()]
+
+def construct_feature_collection(things: List[Thing]) -> FeatureCollection:
+    """
+    Construct a GeoJSON FeatureCollection from a list of Thing objects.
+    """
+    """
+    Jacob's notes during development: 2025-07-28
+    A disadvantage of Django ORM is that you can't make more complicated queries.
+    From what I understand, you can use Django ORM to get all the things and their related locations,
+    but you can't easily filter or join them in a single query. The "joining" has to be done in
+    Python code after fetching the data, which can be less efficient because it's slower than
+    SQL and you have to make more SQL queries to get the related data.
+
+    Also, the filtering is kind of confusing...
+    """
+    thing_ids = [thing.thing_id for thing in things]
+    location_thing_junctions = Location_Thing_Junction.objects.filter(thing_id__in=thing_ids)
+    location_ids = [junction.location_id.location_id for junction in location_thing_junctions]
+    locations = Location.objects.filter(location_id__in=location_ids)
+
+    features = []
+    for thing in things:
+        thing_dict = model_to_dict(thing)
+        thing_dict["location_id"] = thing_dict["location_id"][0].location_id
+        thing_dict["date_created"] = thing.date_created.isoformat()
+        thing_dict["thing_type"] = thing.get_thing_type_display()  # Get human-readable type
+        if thing.thing_type == "W":
+            thing_properties = WellProperties(**thing_dict)
+        elif thing.thing_type == "S":
+            thing_properties = SpringProperties(**thing_dict)
+
+        locations = thing.location_id.all()
+
+        # TODO: assuming, for now, that each thing has a single location. this will have to change if we allow multiple locations per thing.
+        location = locations[0]
+
+        feature = {
+            "type": "Feature",
+            "geometry": {
+                "type": "Point",
+                "coordinates": [location.coordinate.x, location.coordinate.y, location.coordinate.z],
+            },
+            "properties": thing_properties.dict(),
+        }
+
+        features.append(feature)
+
+    response = FeatureCollection(
+        type="FeatureCollection",
+        features=features
+    )
+
+    return response
+
+@router.get('')
+def get_all_things(request):
+    """
+    List all things.
+    """
+    things = get_things()
+    response = construct_feature_collection(things)
+    return response
+
+@router.get('/{thing_id}', response={200: FeatureCollection, 404: NotFoundSchema})
+def get_thing_by_id(request, thing_id: int):
+    """
+    Retrieve a specific thing by its ID.
+    """
+    thing = get_things(thing_id=thing_id)
+    if thing == [None]:
+        return 404, {"detail": f"Thing with id {thing_id} not found"}
+    response = construct_feature_collection(thing)
+    return response

geodjango/samplelocations/api/wells.py

@@ -0,0 +1,55 @@
+# from ninja import Router
+# from ..models import Location, Well, WellScreen, Lexicon
+# from django.shortcuts import get_object_or_404
+
+# router = Router()
+
+
+# @router.post("")
+# def post_well(
+#     request,
+#     location_id: int,
+#     ose_pod_id: str = None,
+#     api_id: str = "",
+#     usgs_id: str = None,
+#     well_depth: float = None,
+#     hole_depth: float = None,
+#     well_type_id: int = None,
+#     casing_diameter: float = None,
+#     casing_depth: float = None,
+#     casing_description: str = None,
+#     construction_notes: str = None,
+#     formation_zone_id: int = None
+# ):
+#     location = get_object_or_404(Location, id=location_id)
+#     well_type = Lexicon.objects.filter(id=well_type_id).first() if well_type_id else None
+#     formation_zone = Lexicon.objects.filter(id=formation_zone_id).first() if formation_zone_id else None
+#     well = Well.objects.create(
+#         location=location,
+#         ose_pod_id=ose_pod_id,
+#         api_id=api_id,
+#         usgs_id=usgs_id,
+#         well_depth=well_depth,
+#         hole_depth=hole_depth,
+#         well_type=well_type,
+#         casing_diameter=casing_diameter,
+#         casing_depth=casing_depth,
+#         casing_description=casing_description,
+#         construction_notes=construction_notes,
+#         formation_zone=formation_zone
+#     )
+#     return {"id": well.id, "location": well.location.id}
+
+
+# @router.post("well-screens/")
+# def post_well_screen(request, well_id: int, screen_depth_top: float, screen_depth_bottom: float, screen_type_id: int = None):
+#     well = get_object_or_404(Well, id=well_id)
+#     screen_type = Lexicon.objects.filter(id=screen_type_id).first() if screen_type_id else None
+#     screen = WellScreen.objects.create(
+#         well=well,
+#         screen_depth_top=screen_depth_top,
+#         screen_depth_bottom=screen_depth_bottom,
+#         screen_type=screen_type
+#     )
+#     return {"id": screen.id, "well": screen.well.id}
+