ADD: get specific grand prix in different ways and get especific positions of driver and constructor standing

Author: Maxbleu

app/api/race.py

@@ -3,7 +3,7 @@
 from sqlalchemy.orm import Session
 from fastapi.responses import JSONResponse
 from fastapi import Depends, APIRouter
-from ..models import Race, FreePractice1Result, FreePractice2Result, FreePractice3Result, FreePractice4Result, Qualifying1Result, Qualifying2Result, QualifyingResult, PreQualifyingResult, StartingGridPosition, RaceResult, DriverOfTheDayResult, FastestLap, SprintRaceResult, SprintQualifyingResult, SprintStartingGridPosition, WarmingUpResult, PitStop, RaceData, RaceConstructorStanding, RaceDriverStanding
+from ..models import FreePractice1Result, FreePractice2Result, FreePractice3Result, FreePractice4Result, Qualifying1Result, Qualifying2Result, QualifyingResult, PreQualifyingResult, StartingGridPosition, RaceResult, DriverOfTheDayResult, FastestLap, SprintRaceResult, SprintQualifyingResult, SprintStartingGridPosition, WarmingUpResult, PitStop, RaceData, RaceConstructorStanding, RaceDriverStanding
 
 router = APIRouter()
 
@@ -460,27 +460,4 @@ async def get_constructor_standing_by_id_and_constructor(race_id: int, construct
         ) \
         .first()
     race_constructors_standing_constructor_position_json = serialize(race_constructors_standing_constructor_position)
-    return JSONResponse(content=race_constructors_standing_constructor_position_json)
-
-@router.get("/{race_id}")
-async def get_race_by_id(race_id: int, db: Session = Depends(get_db)) -> JSONResponse:
-    """Obtener un gran premio por id"""
-    gp = db.query(Race)\
-        .filter(
-            Race.id == race_id
-        ) \
-        .first()
-    gp_json = serialize(gp)
-    return JSONResponse(content=gp_json)
-
-@router.get("/{year}/{round}")
-async def get_race_by_year_and_round(year: int, round: int, db: Session = Depends(get_db)) -> JSONResponse:
-    """Obtener un gran premio por el año y la ronda"""
-    gp = db.query(Race)\
-        .filter(
-            Race.year == year,
-            Race.round == round
-        ) \
-        .first()
-    gp_json = serialize(gp)
-    return JSONResponse(content=gp_json)
+    return JSONResponse(content=race_constructors_standing_constructor_position_json)

app/api/season.py

@@ -1,42 +1,71 @@
 from app.db import get_db
 from app.utils import serialize
 from sqlalchemy.orm import Session
-from fastapi.responses import JSONResponse
 from fastapi import Depends, APIRouter
-from app.models import SeasonEntrantConstructor, SeasonEntrantDriver, SeasonEntrantChassis, SeasonEntrant, SeasonConstructor, SeasonDriver, SeasonTyreManufacturer, SeasonEngineManufacturer, SeasonConstructorStanding, SeasonDriverStanding, Race
+from fastapi.responses import JSONResponse
+from app.models import SeasonEntrantConstructor, SeasonEntrantDriver, SeasonEntrantChassis, SeasonConstructor, SeasonDriver, SeasonTyreManufacturer, SeasonEngineManufacturer, SeasonConstructorStanding, SeasonDriverStanding, Race, GrandPrix
 
 router = APIRouter()
 
-@router.get("/{year}/races")
-async def get_season_races_by_year(year:int, db: Session = Depends(get_db)) -> JSONResponse:
-    """Obtiene todas las carreras de la temporada"""
-    season_races_year = db.query(
+@router.get("/{year}/grand_prix")
+async def get_season_grand_prix_by_year(year:int, db: Session = Depends(get_db)) -> JSONResponse:
+    """Obtiene todos los grand prix de la temporada"""
+    season_grand_prix_year = db.query(
         Race.id,
         Race.year,
         Race.round,
         Race.grand_prix_id,
         Race.circuit_id
         ) \
         .filter(Race.year == year).all()
-    season_races_year_json = serialize(season_races_year)
-    return JSONResponse(content=season_races_year_json)
+    season_grand_prix_year_json = serialize(season_grand_prix_year)
+    return JSONResponse(content=season_grand_prix_year_json)
+
+@router.get("/{year}/grand_prix/{race_id}")
+async def get_grand_prix_by_race_id(year: int, race_id: int, db: Session = Depends(get_db)) -> JSONResponse:
+    """Obtiene un grand prix de una temporada por race_id"""
+    grand_prix = db.query(
+        Race.id,
+        Race.year,
+        Race.round,
+        Race.grand_prix_id,
+        Race.circuit_id
+        ) \
+        .filter(
+            Race.year == year,
+            Race.id == race_id
+        ) \
+        .first()
+    grand_prix_json = serialize(grand_prix)
+    return JSONResponse(content=grand_prix_json)
 
-@router.get("/{year}/entrants")
-async def get_season_entrants_by_year(year:int, db: Session = Depends(get_db)) -> JSONResponse:
-    """Obtiene todos los participantes de una temporada"""
-    season_entrants_year = db.query(SeasonEntrant).filter(SeasonEntrant.year == year).all()
-    season_entrants_year_json = serialize(season_entrants_year)
-    return JSONResponse(content=season_entrants_year_json)
+@router.get("/{year}/{round}")
+async def get_grand_prix_by_year_and_round(year: int, round: int, db: Session = Depends(get_db)) -> JSONResponse:
+    """Obtener un grand prix por el año y la ronda"""
+    grand_prix = db.query(
+        Race.id,
+        Race.year,
+        Race.round,
+        Race.grand_prix_id,
+        Race.circuit_id
+    )\
+        .filter(
+            Race.year == year,
+            Race.round == round
+        ) \
+        .first()
+    grand_prix_json = serialize(grand_prix)
+    return JSONResponse(content=grand_prix_json)
 
 @router.get("/{year}/constructors")
-async def get_season_constructors_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
+async def get_constructor_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
     """Obtiene todos los constructores entrantes de una temporada"""
     season_constructors = db.query(SeasonEntrantConstructor).filter(SeasonEntrantConstructor.year == year).distinct().all()
     season_constructors_json = serialize(season_constructors)
     return JSONResponse(content=season_constructors_json)
 
 @router.get("/{year}/constructors/{constructor_id}")
-async def get_season_constructor_by_year_and_constructor_id(year: int, constructor_id: str, db: Session = Depends(get_db)) -> JSONResponse:
+async def get_constructor_by_year_and_constructor_id(year: int, constructor_id: str, db: Session = Depends(get_db)) -> JSONResponse:
     """Obtiene las estadísticas de un constructor de una temporada"""
     season_constructor = db.query(SeasonConstructor)\
         .filter(
@@ -48,14 +77,14 @@ async def get_season_constructor_by_year_and_constructor_id(year: int, construct
     return JSONResponse(content=season_constructor_json)
 
 @router.get("/{year}/drivers")
-async def get_season_drivers_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
+async def get_driver_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
     """Obtiene todos los pilotos entrantes en una temporada"""
     season_drivers = db.query(SeasonEntrantDriver).filter(SeasonEntrantDriver.year == year).distinct().all()
     season_drivers_json = serialize(season_drivers)
     return JSONResponse(content=season_drivers_json)
 
 @router.get("/{year}/drivers/{driver_id}")
-async def get_season_driver_by_year_and_driver_id(year: int, driver_id: str, db: Session = Depends(get_db)) -> JSONResponse:
+async def get_driver_by_year_and_driver_id(year: int, driver_id: str, db: Session = Depends(get_db)) -> JSONResponse:
     """Obtiene las estadísticas de un driver de una temporada"""
     season_driver = db.query(SeasonDriver)\
         .filter(
@@ -67,21 +96,21 @@ async def get_season_driver_by_year_and_driver_id(year: int, driver_id: str, db:
     return JSONResponse(content=season_driver_json)
 
 @router.get("/{year}/tyres/stats")
-async def get_season_tyres_stats_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
+async def get_tyres_stats_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
     """Obtiene las estadísticas de los neumáticos por año"""
     season_tyre_manufacturers_stats = db.query(SeasonTyreManufacturer).filter(SeasonTyreManufacturer.year == year).all()
     season_tyre_manufacturers_stats_json = serialize(season_tyre_manufacturers_stats)
     return JSONResponse(content=season_tyre_manufacturers_stats_json)
 
 @router.get("/{year}/engines/stats")
-async def get_season_engines_stats_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
+async def get_engines_stats_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
     """Obtiene las estadísticas de los motoristas por año"""
     season_engines_manufacturers_stats = db.query(SeasonEngineManufacturer).filter(SeasonEngineManufacturer.year == year).all()
     season_engines_manufacturers_stats_json = serialize(season_engines_manufacturers_stats)
     return JSONResponse(content=season_engines_manufacturers_stats_json)
 
 @router.get("/{year}/chassis")
-async def get_season_chassis_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
+async def get_chassis_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
     """Obtiene todos los chassis usados en una temporada específica"""
     season_chassis = db.query(SeasonEntrantChassis)\
         .filter(
@@ -92,21 +121,43 @@ async def get_season_chassis_by_year(year: int, db: Session = Depends(get_db)) -
     return JSONResponse(content=season_chassis_json)
 
 @router.get("/{year}/standing/drivers")
-async def get_season_driver_standing_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
+async def get_driver_standing_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
     """Obtiene el campeonato de pilotos de una temporada"""
-    driver_standing = db.query(SeasonDriverStanding) \
+    drivers_standing = db.query(SeasonDriverStanding) \
         .filter(
             SeasonDriverStanding.year == year
         ).all()
+    drivers_standing_json = serialize(drivers_standing)
+    return JSONResponse(content=drivers_standing_json)
+
+@router.get("/{year}/standing/drivers/{driver_id}")
+async def get_driver_standing_specific_by_year_and_driver_id(year: int, driver_id: str, db: Session = Depends(get_db)) -> JSONResponse:
+    """Obtiene una posición específica del campeonato de pilotos de una temporada"""
+    driver_standing = db.query(SeasonDriverStanding) \
+        .filter(
+            SeasonDriverStanding.year == year,
+            SeasonDriverStanding.driver_id == driver_id
+        ).first()
     driver_standing_json = serialize(driver_standing)
     return JSONResponse(content=driver_standing_json)
 
 @router.get("/{year}/standing/constructors")
-async def get_season_constructor_standing_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
+async def get_constructor_standing_by_year(year: int, db: Session = Depends(get_db)) -> JSONResponse:
     """Obtiene el campeonato de constructores de una temporada"""
-    constructor_standing = db.query(SeasonConstructorStanding) \
+    constructors_standing = db.query(SeasonConstructorStanding) \
         .filter(
             SeasonConstructorStanding.year == year
         ).all()
+    constructors_standing_json = serialize(constructors_standing)
+    return JSONResponse(content=constructors_standing_json)
+
+@router.get("/{year}/standing/constructors/{constructor_id}")
+async def get_constructor_standing_specific_by_year_and_constructor_id(year: int, constructor_id: str, db: Session = Depends(get_db)) -> JSONResponse:
+    """Obtiene una posición específica del campeonato de constructores de una temporada"""
+    constructor_standing = db.query(SeasonConstructorStanding) \
+        .filter(
+            SeasonConstructorStanding.year == year,
+            SeasonConstructorStanding.constructor_id == constructor_id
+        ).first()
     constructor_standing_json = serialize(constructor_standing)
     return JSONResponse(content=constructor_standing_json)