Add endpoint & logic for getting multiple stops map

Author: David-Lor

README.md

@@ -95,6 +95,7 @@ _La API puede devolver información de Paradas y listados en tiempo real de los
 - Add Near Stops endpoint
 - Add endpoint for static maps and StreetView acquisition
 - Add endpoints for static buses info
+- On multi-stop map generation, return markers showing stop IDs
 - Add integration tests
 - Add detailed install & configuration instructions
 - Improve endpoint and services/controllers in-code organization
@@ -106,6 +107,7 @@ _La API puede devolver información de Paradas y listados en tiempo real de los
 - _Añadir endpoint para consulta de paradas cercanas a ubicación_
 - _Añadir endpoint para obtención de mapas estáticos y StreetView_
 - _Añadir endpoints para consulta de información estática de buses_
+- _En generación de mapas de varias paradas, devolver marcadores mostrando IDs de parada_
 - _Añadir tests de integración_
 - _Añadir instrucciones detalladas de instalación y configuración_
 - _Mejorar organización en código de endpoints y servicios/controladores_

vigobusapi/app.py

@@ -4,11 +4,12 @@
 
 # # Native # #
 import io
+import json
 from typing import Optional, Set
 
 # # Installed # #
 import uvicorn
-from fastapi import FastAPI, Response, Query, HTTPException
+from fastapi import FastAPI, Response, Query, Depends, HTTPException
 from starlette.responses import StreamingResponse
 
 # # Project # #
@@ -87,13 +88,24 @@ async def endpoint_get_buses(stop_id: int, get_all_buses: bool = False):
         return buses_result.dict()
 
 
+class MapQueryParams:
+    def __init__(
+            self,
+            size_x: int = google_maps_settings.stop_map_default_size_x,
+            size_y: int = google_maps_settings.stop_map_default_size_y,
+            zoom: int = google_maps_settings.stop_map_default_zoom,
+            map_type: GoogleMapRequest.MapTypes = google_maps_settings.stop_map_default_type
+    ):
+        self.size_x = size_x
+        self.size_y = size_y
+        self.zoom = zoom
+        self.map_type = map_type
+
+
 @app.get("/stop/{stop_id}/map")
 async def endpoint_get_stop_map(
         stop_id: int,
-        size_x: int = google_maps_settings.stop_map_default_size_x,
-        size_y: int = google_maps_settings.stop_map_default_size_y,
-        zoom: int = google_maps_settings.stop_map_default_zoom,
-        map_type: GoogleMapRequest.MapTypes = google_maps_settings.stop_map_default_type
+        map_params: MapQueryParams = Depends()
 ):
     """Get a picture of a map with the stop location marked on it."""
     stop = await get_stop(stop_id)
@@ -103,16 +115,53 @@ async def endpoint_get_stop_map(
     map_request = GoogleMapRequest(
         location_x=stop.lat,
         location_y=stop.lon,
-        size_x=size_x,
-        size_y=size_y,
-        zoom=zoom,
-        map_type=map_type,
+        size_x=map_params.size_x,
+        size_y=map_params.size_y,
+        zoom=map_params.zoom,
+        map_type=map_params.map_type,
         tags=[GoogleMapRequest.Tag(location_x=stop.lat, location_y=stop.lon)]
     )
     map_data = await get_map(map_request)
     return StreamingResponse(io.BytesIO(map_data), media_type="image/png")
 
 
+@app.get("/stops/map")
+async def endpoint_get_stops_map(
+        stops_ids: Set[int] = Query(None, alias="stop_id", min_items=1, max_items=35),
+        map_params: MapQueryParams = Depends(),
+):
+    """Get a picture of a map with the locations of the given stops marked on it.
+    The marks are labelled in the same order as the given stops ids.
+
+    A header "X-Stops-Tags" is returned, being a JSON associating the Stops IDs with the tag label on the map,
+    with the format: {"<stop id>" : "<tag label>"}
+    """
+    stops = await get_stops(stops_ids)
+
+    stops_tags = list()
+    stops_tags_relation = dict()
+    for i, stop in enumerate(stops):
+        tag_label = GoogleMapRequest.Tag.get_allowed_labels()[i]
+        tag = GoogleMapRequest.Tag(label=tag_label, location_x=stop.lat, location_y=stop.lon)
+        stops_tags.append(tag)
+        stops_tags_relation[stop.stop_id] = tag_label
+
+    map_request = GoogleMapRequest(
+        size_x=map_params.size_x,
+        size_y=map_params.size_y,
+        zoom=map_params.zoom,
+        map_type=map_params.map_type,
+        tags=stops_tags
+    )
+    map_data = await get_map(map_request)
+
+    return StreamingResponse(
+        content=io.BytesIO(map_data),
+        media_type="image/png",
+        headers={"X-Stops-Tags": json.dumps(stops_tags_relation)}
+    )
+
+
 @app.get("/stop/{stop_id}/photo")
 async def endpoint_get_stop_photo(
         stop_id: int,
@@ -130,6 +179,8 @@ async def endpoint_get_stop_photo(
         size_y=size_y
     )
     photo_data = await get_photo(photo_request)
+    if not photo_data:
+        raise HTTPException(status_code=404, detail="No StreetView photo available for the stop location")
     return StreamingResponse(io.BytesIO(photo_data), media_type="image/png")
 
 

vigobusapi/services/google_maps.py

@@ -3,6 +3,7 @@
 """
 
 # # Native # #
+import string
 from enum import Enum
 from typing import *
 
@@ -30,7 +31,9 @@ class _GoogleMapsBaseRequest(BaseModel, ChecksumableClass):
     size_y: int
 
     @property
-    def location_str(self):
+    def location_str(self) -> Optional[str]:
+        if self.location_x is None or self.location_y is None:
+            return None
         return f"{self.location_x},{self.location_y}"
 
     @property
@@ -54,10 +57,16 @@ class GoogleMapRequest(_GoogleMapsBaseRequest):
     # Embed classes #
 
     class Tag(BaseModel, ChecksumableClass):
-        label: Optional[str]  # single uppercase char (A~Z, 0~9)
+        __ALLOWED_LABELS = [*[str(i) for i in range(1, 10)], *[c for c in string.ascii_uppercase]]
+
+        label: Optional[str] = None  # TODO constrain values accepted (avoid enum?)
         location_x: float
         location_y: float
 
+        @classmethod
+        def get_allowed_labels(cls):
+            return cls.__ALLOWED_LABELS
+
         @property
         def location_str(self):
             return f"{self.location_x},{self.location_y}"
@@ -107,8 +116,10 @@ def checksum_hash(self):
 
     # Class Attributes #
 
+    location_x: Optional[float] = None
+    location_y: Optional[float] = None
     tags: Optional[List[Tag]] = None
-    zoom: int  # TODO may be used by Streetview as well (refactor if so)
+    zoom: int
     """https://developers.google.com/maps/documentation/maps-static/start#Zoomlevels"""
     map_type: MapTypes
 
@@ -153,14 +164,17 @@ async def get_map(request: GoogleMapRequest) -> bytes:
     logger.bind(map_request=request.dict()).debug("Requesting Google Static Map picture...")
     # TODO cache loaded pictures
     params = [
-        ("center", request.location_str),
         ("size", request.size_str),
-        ("zoom", str(request.zoom)),
         ("maptype", request.map_type.value),
         ("language", settings.language),
         ("format", "png8"),
     ]
 
+    location_str = request.location_str
+    if location_str:
+        params.append(("center", location_str))
+        params.append(("zoom", str(request.zoom)))
+
     if request.tags:
         for tag in request.tags:
             tag_param_values = [tag.location_str]  # Location always at the end

vigobusapi/services/http_requester.py

@@ -75,10 +75,12 @@ async def http_request(
                 last_status_code = response.status_code
 
                 # Log response
-                response_body = response.text
-                response_body_size = len(response.content)
-                if response_body_size > 500000 or "\\x00\\" in response_body:  # 500kB
+                response_body = response.content
+                response_body_size = len(response_body)
+                if response_body_size > 500000 or b"\x00" in response_body:  # 500kB
                     response_body = "binary or too large"
+                else:
+                    response_body = response.text
                 logger.bind(
                     response_elapsed_time=response_time,
                     response_status_code=last_status_code,

vigobusapi/utils.py

@@ -5,8 +5,15 @@
 # # Native # #
 import abc
 import hashlib
+import json
+import base64 as _base64
+from typing import List, Dict, Union, Any
 
-__all__ = ("ChecksumableClass", "new_hash_values", "update_hash_values")
+# # Installed # #
+import pydantic
+from pydantic.json import pydantic_encoder
+
+__all__ = ("ChecksumableClass", "new_hash_values", "update_hash_values", "base64_encode", "json_encode_object")
 
 
 class ChecksumableClass(abc.ABC):
@@ -42,3 +49,21 @@ def new_hash_values(*args, algorithm: str):
     Returns the hash object (the hash/checksum value can be acquired by using str(output))."""
     _hash = hashlib.new(algorithm)
     return update_hash_values(*args, _hash=_hash)
+
+
+def base64_encode(data: str) -> str:
+    """Encode the given string as base64"""
+    return _base64.urlsafe_b64encode(data.encode()).decode()
+
+
+def json_encode_object(
+        obj: Union[pydantic.BaseModel, List[pydantic.BaseModel], Dict[Any, pydantic.BaseModel]],
+        base64: bool = False
+) -> str:
+    """Given a Pydantic object, a List of Pydantic objects, or a Dict with Pydantic objects, convert to JSON string.
+    If base64=True, return the JSON result base64-encoded.
+    """
+    encoded = json.dumps(obj, default=pydantic_encoder)
+    if base64:
+        return base64_encode(encoded)
+    return encoded