fix: Fixed route update mechanism (#208)

* refactor: Made device_id and media_id madnatory in the alert table

* refactor: Refactored schemas

* docs: Added stop-dev command to Makefile

* feat: Added DEBUG to each docker compose and restart

* refactor: Deprecated specified_only in update_entry

* refactor: Deprecated update routes of alert table

* refactor: Reflected schemas refacto

* test: Fixed unittests

* test: Fixed unittests

* refactor: Deprecated media update route

* feat: Enforced strict update

* refactor: Reflected changes from API

* test: Updated unittests accordingly

* style: Fixed style

* test: Fixed unittests

* fix: Fixed validators

* test: Updated unittest

* test: Removed debug code

* test: Added unittest for webhooks

* test: Fixed webhook unittests

Author: frgfm

Makefile

@@ -33,6 +33,9 @@ run-dev:
 	docker build src/. -t pyroapi:python3.8-alpine3.10
 	docker-compose -f docker-compose-dev.yml up -d --build
 
+stop-dev:
+	docker-compose -f docker-compose-dev.yml down
+
 # Run tests for the library
 test:
 	docker build src/. -t pyroapi:python3.8-alpine3.10

client/pyroclient/client.py

@@ -116,11 +116,11 @@ def heartbeat(self) -> Response:
 
     def update_my_location(
         self,
-        lat: Union[float, None] = None,
-        lon: Union[float, None] = None,
-        elevation: Union[float, None] = None,
-        yaw: Union[float, None] = None,
-        pitch: Union[float, None] = None,
+        lat: float,
+        lon: float,
+        elevation: float,
+        yaw: float,
+        pitch: float,
     ) -> Response:
         """Updates the location of the device
 
@@ -132,22 +132,7 @@ def update_my_location(
         Returns:
             HTTP response containing the update device info
         """
-        payload = {}
-
-        if lat is not None:
-            payload["lat"] = lat
-        if lon is not None:
-            payload["lon"] = lon
-        if elevation is not None:
-            payload["elevation"] = elevation
-        if yaw is not None:
-            payload["yaw"] = yaw
-        if pitch is not None:
-            payload["pitch"] = pitch
-
-        if len(payload) == 0:
-            raise ValueError("At least one location information" + "(lat, lon, elevation, yaw, pitch) must be filled")
-
+        payload = {"lat": lat, "lon": lon, "elevation": elevation, "yaw": yaw, "pitch": pitch}
         return requests.put(self.routes["update-my-location"], headers=self.headers, json=payload)
 
     def create_event(self, lat: float, lon: float) -> Response:
@@ -198,9 +183,9 @@ def send_alert(
         lat: float,
         lon: float,
         device_id: int,
+        media_id: int,
         azimuth: Union[float, None] = None,
         event_id: Union[int, None] = None,
-        media_id: Union[int, None] = None,
     ) -> Response:
         """Raise an alert to the API.
 
@@ -212,10 +197,10 @@ def send_alert(
         Args:
             lat: the latitude of the alert
             lon: the longitude of the alert
+            device_id: ID of the device that sent this alert
+            media_id: media ID linked to this alert
             azimuth: the azimuth of the alert
             event_id: the ID of the event this alerts relates to
-            device_id: the ID of the device that raised this alert
-            media_id: optional media ID linked to this alert
 
         Returns:
             HTTP response containing the created alert
@@ -232,9 +217,9 @@ def send_alert_from_device(
         self,
         lat: float,
         lon: float,
+        media_id: int,
         azimuth: Union[float, None] = None,
         event_id: Union[int, None] = None,
-        media_id: Union[int, None] = None,
     ) -> Response:
         """Raise an alert to the API from a device (no need to specify device ID).
 
@@ -246,9 +231,9 @@ def send_alert_from_device(
         Args:
             lat: the latitude of the alert
             lon: the longitude of the alert
+            media_id: media ID linked to this alert
             azimuth: the azimuth of the alert
             event_id: the ID of the event this alerts relates to
-            media_id: optional media ID linked to this alert
 
         Returns:
             HTTP response containing the created alert

docker-compose-dev.yml

@@ -5,12 +5,14 @@ services:
     build:
       context: src
       dockerfile: Dockerfile-dev
+    restart: always
     command: uvicorn app.main:app --reload --workers 1 --host 0.0.0.0 --port 8080
     volumes:
       - ./src/:/app/
     ports:
       - 8080:8080
     environment:
+      - DEBUG=true
       - DATABASE_URL=postgresql://dummy_pg_user:dummy_pg_pwd@db/dummy_pg_db
       - TEST_DATABASE_URL=postgresql://dummy_pg_tuser:dummy_pg_tpwd@db_test/dummy_pg_tdb
       - SUPERUSER_LOGIN=dummy_login

docker-compose.yml

@@ -3,12 +3,14 @@ version: '3.7'
 services:
   pyroapi:
     build: src
+    restart: always
     command: uvicorn app.main:app --reload --workers 1 --host 0.0.0.0 --port 8080
     volumes:
       - ./src/:/app/
     ports:
       - 8080:8080
     environment:
+      - DEBUG=false
       - DATABASE_URL=postgresql://dummy_pg_user:dummy_pg_pwd@db/dummy_pg_db
       - SUPERUSER_LOGIN=dummy_login
       - SUPERUSER_PWD=dummy_pwd

src/app/api/crud/accesses.py

@@ -77,7 +77,7 @@ async def create_accessed_entry(
     return entry
 
 
-async def update_accessed_entry(table: Table, accesses: Table, entry_id: int, payload: Any, only_specified=True):
+async def update_accessed_entry(table: Table, accesses: Table, entry_id: int, payload: Any):
     """Update an entry with a special treatment regarding login: if login is set -> update corresponding access."""
     # Ensure database consistency between tables with a transaction (login must remain the same in table & accesses)
     async with base.database.transaction():
@@ -94,7 +94,7 @@ async def update_accessed_entry(table: Table, accesses: Table, entry_id: int, pa
                 await update_login(accesses, payload.login, origin_entry["access_id"])
 
         # Update entry with input payload
-        entry = await base.update_entry(table, payload, entry_id, only_specified)
+        entry = await base.update_entry(table, payload, entry_id)
 
     return entry
 

src/app/api/crud/authorizations.py

@@ -7,8 +7,8 @@
 from sqlalchemy import Table
 
 from app.api import crud
-from app.api.schemas import AccessType
 from app.db import accesses
+from app.db.models import AccessType
 
 
 async def is_in_same_group(table: Table, entry_id: int, group_id: int) -> bool:

src/app/api/crud/base.py

@@ -84,27 +84,17 @@ async def get_entry(table: Table, entry_id: int = Path(..., gt=0)) -> Dict[str,
     return dict(entry)
 
 
-async def update_entry(
-    table: Table, payload: BaseModel, entry_id: int = Path(..., gt=0), only_specified: bool = True
-) -> Dict[str, Any]:
+async def update_entry(table: Table, payload: BaseModel, entry_id: int = Path(..., gt=0)) -> Dict[str, Any]:
     payload_dict = payload.dict()
 
-    if only_specified:
-        # Dont update columns for null fields
-        payload_dict = {k: v for k, v in payload_dict.items() if v is not None}
-
     _id = await put(entry_id, payload_dict, table)
 
     if not isinstance(_id, int):
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail=f"Table {table.name} has no entry with id={entry_id}"
         )
 
-    if only_specified:
-        # Retrieve complete record values
-        return dict(await get(entry_id, table))
-    else:
-        return {**payload.dict(), "id": entry_id}
+    return {**payload.dict(), "id": entry_id}
 
 
 async def delete_entry(table: Table, entry_id: int = Path(..., gt=0)) -> Dict[str, Any]:

src/app/api/deps.py

@@ -10,8 +10,9 @@
 
 import app.config as cfg
 from app.api import crud
-from app.api.schemas import AccessRead, AccessType, DeviceOut, TokenPayload, UserRead
+from app.api.schemas import AccessRead, DeviceOut, TokenPayload, UserRead
 from app.db import accesses, devices, users
+from app.db.models import AccessType
 
 # Scope definition
 oauth2_scheme = OAuth2PasswordBearer(

src/app/api/routes/accesses.py

@@ -9,8 +9,9 @@
 
 from app.api import crud
 from app.api.deps import get_current_access
-from app.api.schemas import AccessRead, AccessType
+from app.api.schemas.accesses import AccessRead
 from app.db import accesses
+from app.db.models import AccessType
 
 router = APIRouter()
 

src/app/api/routes/alerts.py

@@ -10,12 +10,13 @@
 from sqlalchemy import select
 
 from app.api import crud
-from app.api.crud.authorizations import check_group_read, check_group_update, is_admin_access
+from app.api.crud.authorizations import check_group_read, is_admin_access
 from app.api.crud.groups import get_entity_group_id
 from app.api.deps import get_current_access, get_current_device
 from app.api.external import post_request
-from app.api.schemas import AccessType, AlertBase, AlertIn, AlertMediaId, AlertOut, DeviceOut
+from app.api.schemas import AlertBase, AlertIn, AlertOut, DeviceOut
 from app.db import alerts, events, get_session, media, models
+from app.db.models import AccessType
 
 router = APIRouter()
 
@@ -110,20 +111,6 @@ async def fetch_alerts(
         return retrieved_alerts
 
 
-@router.put("/{alert_id}/", response_model=AlertOut, summary="Update information about a specific alert")
-async def update_alert(
-    payload: AlertIn,
-    alert_id: int = Path(..., gt=0),
-    requester=Security(get_current_access, scopes=[AccessType.admin, AccessType.user]),
-):
-    """
-    Based on a alert_id, updates information about the specified alert
-    """
-    requested_group_id = await get_entity_group_id(alerts, alert_id)
-    await check_group_update(requester.id, requested_group_id)
-    return await crud.update_entry(alerts, payload, alert_id)
-
-
 @router.delete("/{alert_id}/", response_model=AlertOut, summary="Delete a specific alert")
 async def delete_alert(alert_id: int = Path(..., gt=0), _=Security(get_current_access, scopes=[AccessType.admin])):
     """
@@ -132,29 +119,6 @@ async def delete_alert(alert_id: int = Path(..., gt=0), _=Security(get_current_a
     return await crud.delete_entry(alerts, alert_id)
 
 
-@router.put("/{alert_id}/link-media", response_model=AlertOut, summary="Link an alert to a media")
-async def link_media(
-    payload: AlertMediaId,
-    alert_id: int = Path(..., gt=0),
-    current_device: DeviceOut = Security(get_current_device, scopes=[AccessType.device]),
-):
-    """
-    Based on a alert_id, and media information as arguments, link the specified alert to a media
-    """
-    # Check that alert is linked to this device
-    existing_alert = await crud.fetch_one(alerts, {"id": alert_id, "device_id": current_device.id})
-    if existing_alert is None:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Unable to find alert with id={alert_id} & device_id={current_device.id}.",
-        )
-
-    await check_media_existence(payload.media_id)
-    existing_alert = dict(**existing_alert)
-    existing_alert["media_id"] = payload.media_id
-    return await crud.update_entry(alerts, AlertIn(**existing_alert), alert_id)
-
-
 @router.get("/ongoing", response_model=List[AlertOut], summary="Get the list of ongoing alerts")
 async def fetch_ongoing_alerts(
     requester=Security(get_current_access, scopes=[AccessType.admin, AccessType.user]), session=Depends(get_session)