add list of races for each driver

Author: guyver2

server/src/api.rs

@@ -316,6 +316,10 @@ pub fn create_api_router(race_state: SharedRaceState, db_pool: Option<PgPool>) -
             get(get_team_registrations),
         )
         .route("/drivers/{driver_id}", get(get_driver))
+        .route(
+            "/drivers/{driver_id}/race-results",
+            get(get_driver_race_results),
+        )
         .route("/drivers/{driver_id}/buy", post(buy_driver))
         .route("/drivers/{driver_id}/assign-car", post(assign_driver_car))
         .route("/cars/{car_id}", get(get_car))
@@ -722,6 +726,33 @@ async fn get_driver(
     Ok(success(Some(driver_response), None))
 }
 
+// Get race results for a driver
+async fn get_driver_race_results(
+    Path(driver_id): Path<String>,
+    Query(params): Query<PaginationParams>,
+    State(state): State<AppState>,
+) -> ApiResult<Json<ApiResponse<Vec<crate::database::DriverRaceResultDb>>>> {
+    let pool = state
+        .db_pool
+        .as_ref()
+        .ok_or_else(|| ApiError::InternalError("Database not available".to_string()))?;
+    let uuid = Uuid::parse_str(&driver_id)
+        .map_err(|_| ApiError::BadRequest(format!("Invalid driver ID format: {}", driver_id)))?;
+
+    // Verify driver exists
+    let _driver = tdb::get_driver_by_id(pool, uuid)
+        .await
+        .map_err(|e| ApiError::InternalError(format!("Failed to fetch driver: {}", e)))?
+        .ok_or_else(|| ApiError::NotFound(format!("Driver with ID {} not found", driver_id)))?;
+
+    // Get race results
+    let results = tdb::get_race_results_by_driver(pool, uuid, params.limit, params.offset)
+        .await
+        .map_err(|e| ApiError::InternalError(format!("Failed to fetch race results: {}", e)))?;
+
+    Ok(success(Some(results), None))
+}
+
 // Buy a driver
 async fn buy_driver(
     Path(driver_id): Path<String>,

server/src/database/models.rs

@@ -273,3 +273,13 @@ pub struct CreateRaceResultRequest {
     pub laps_completed: i32,
     pub total_distance_km: f32,
 }
+
+// Response DTO for driver race results with track and race information
+#[derive(Debug, Clone, Serialize, Deserialize, FromRow)]
+pub struct DriverRaceResultDb {
+    pub race_result_id: Uuid,
+    pub race_id: Uuid, // UUID of the race, used for linking to the race page
+    pub track_name: String,
+    pub race_date: Option<DateTime<Utc>>, // start_datetime from race table
+    pub final_position: i32,
+}

server/src/database/queries.rs

@@ -793,13 +793,20 @@ pub async fn list_races(
     status_filter: Option<Vec<&str>>,
 ) -> Result<Vec<RaceDb>, sqlx::Error> {
     let query = if let Some(statuses) = status_filter {
+        // Determine sort order: DESC for finished/canceled races (done), ASC for upcoming races
+        let is_done = statuses
+            .iter()
+            .any(|s| *s == "FINISHED" || *s == "CANCELED");
+        let order_direction = if is_done { "DESC" } else { "ASC" };
+
         // Build a query with status filtering
         let status_placeholders: Vec<String> =
             (1..=statuses.len()).map(|i| format!("${}", i)).collect();
         let status_list = status_placeholders.join(", ");
         let base_query = format!(
-            "SELECT id, track_id, laps, status::text as status, start_datetime, creator_id, description, created_at, updated_at FROM race WHERE status::text IN ({}) ORDER BY start_datetime ASC LIMIT ${} OFFSET ${}",
+            "SELECT id, track_id, laps, status::text as status, start_datetime, creator_id, description, created_at, updated_at FROM race WHERE status::text IN ({}) ORDER BY COALESCE(start_datetime, created_at) {} LIMIT ${} OFFSET ${}",
             status_list,
+            order_direction,
             statuses.len() + 1,
             statuses.len() + 2
         );
@@ -814,9 +821,9 @@ pub async fn list_races(
             .fetch_all(pool)
             .await?
     } else {
-        // No status filter, return all races
+        // No status filter, return all races (ascending by default)
         sqlx::query_as::<_, RaceDb>(
-            "SELECT id, track_id, laps, status::text as status, start_datetime, creator_id, description, created_at, updated_at FROM race ORDER BY start_datetime ASC LIMIT $1 OFFSET $2"
+            "SELECT id, track_id, laps, status::text as status, start_datetime, creator_id, description, created_at, updated_at FROM race ORDER BY COALESCE(start_datetime, created_at) ASC LIMIT $1 OFFSET $2"
         )
         .bind(limit)
         .bind(offset)
@@ -1285,6 +1292,49 @@ pub async fn get_race_result_by_race_and_car(
     Ok(result)
 }
 
+pub async fn get_race_results_by_driver(
+    pool: &PgPool,
+    driver_id: Uuid,
+    limit: i64,
+    offset: i64,
+) -> Result<Vec<DriverRaceResultDb>, sqlx::Error> {
+    let results = sqlx::query_as::<_, DriverRaceResultDb>(
+        r#"
+        SELECT 
+            rr.id as race_result_id,
+            rr.race_id,
+            t.name as track_name,
+            r.start_datetime as race_date,
+            rr.final_position
+        FROM race_result rr
+        INNER JOIN race r ON rr.race_id = r.id
+        INNER JOIN track t ON r.track_id = t.id
+        WHERE rr.driver_id = $1
+        ORDER BY COALESCE(r.start_datetime, r.created_at) DESC
+        LIMIT $2 OFFSET $3
+        "#,
+    )
+    .bind(driver_id)
+    .bind(limit)
+    .bind(offset)
+    .fetch_all(pool)
+    .await?;
+
+    Ok(results)
+}
+
+pub async fn count_race_results_by_driver(
+    pool: &PgPool,
+    driver_id: Uuid,
+) -> Result<i64, sqlx::Error> {
+    let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM race_result WHERE driver_id = $1")
+        .bind(driver_id)
+        .fetch_one(pool)
+        .await?;
+
+    Ok(count)
+}
+
 /// Save race results for all cars in a race
 /// This function takes a snapshot of all cars and their final state
 pub async fn save_race_results(