feat: Map medal times (#93)

* feat: Map medal times
* Add medal times SQL column bound to maps table with migration
* Fill them with the `/map/insert` game API service, that updates them
  when available, like the `cps_number` field
* Add comment to explain medal times check

Author: ahmadbky

crates/entity/src/entities/maps.rs

@@ -23,6 +23,15 @@ pub struct Model {
     ///
     /// This was created for future features.
     pub linked_map: Option<u32>,
+
+    /// The bronze time of the map.
+    pub bronze_time: Option<i32>,
+    /// The silver time of the map.
+    pub silver_time: Option<i32>,
+    /// The gold time of the map.
+    pub gold_time: Option<i32>,
+    /// The author time of the map.
+    pub author_time: Option<i32>,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

crates/game_api/src/http/map.rs

@@ -12,8 +12,8 @@ use entity::{maps, player_rating, players, rating, rating_kind};
 use futures::{StreamExt, future::try_join_all};
 use records_lib::Database;
 use sea_orm::{
-    ActiveValue::Set, ColumnTrait as _, EntityTrait as _, FromQueryResult, PaginatorTrait,
-    QueryFilter, QuerySelect, prelude::Expr, sea_query::Func,
+    ActiveModelTrait as _, ActiveValue::Set, ColumnTrait as _, EntityTrait as _, FromQueryResult,
+    PaginatorTrait, QueryFilter, QuerySelect, prelude::Expr, sea_query::Func,
 };
 use serde::{Deserialize, Serialize};
 
@@ -29,13 +29,43 @@ pub fn map_scope() -> Scope {
         .route("/reset_ratings", web::post().to(reset_ratings))
 }
 
+#[derive(Deserialize)]
+#[cfg_attr(test, derive(Serialize))]
+struct MedalTimes {
+    bronze_time: i32,
+    silver_time: i32,
+    gold_time: i32,
+    author_time: i32,
+}
+
 #[derive(Deserialize)]
 #[cfg_attr(test, derive(Serialize))]
 struct UpdateMapBody {
     name: String,
     map_uid: String,
     cps_number: u32,
     author: PlayerInfoNetBody,
+    medal_times: Option<MedalTimes>,
+}
+
+fn update_active_model_medal_times(
+    active_model: &mut maps::ActiveModel,
+    medal_times: Option<MedalTimes>,
+) {
+    // If the request body contains medal times, it doesn't mean that the map has medal times saved.
+    // This is because ManiaScript can't encode null values when serializing to JSON. So it encodes
+    // 0 for integers by default.
+    if let Some(medal_times) = medal_times
+        && medal_times.author_time > 0
+        && medal_times.bronze_time > medal_times.silver_time
+        && medal_times.silver_time > medal_times.gold_time
+        && medal_times.gold_time > medal_times.author_time
+    {
+        active_model.bronze_time = Set(Some(medal_times.bronze_time));
+        active_model.silver_time = Set(Some(medal_times.silver_time));
+        active_model.gold_time = Set(Some(medal_times.gold_time));
+        active_model.author_time = Set(Some(medal_times.author_time));
+    }
 }
 
 async fn insert(
@@ -46,24 +76,42 @@ async fn insert(
     let map = records_lib::map::get_map_from_uid(&conn, &body.map_uid).await?;
 
     if let Some(map) = map {
-        if map.cps_number.is_none() {
-            let map = maps::ActiveModel {
-                cps_number: Set(Some(body.cps_number)),
-                ..From::from(map)
-            };
-            maps::Entity::update(map).exec(&conn).await.with_api_err()?;
+        let is_map_medals_empty = map.bronze_time.is_none()
+            && map.silver_time.is_none()
+            && map.gold_time.is_none()
+            && map.author_time.is_none();
+
+        let is_map_cps_number_empty = map.cps_number.is_none();
+
+        let mut updated_map = maps::ActiveModel::from(map);
+
+        if is_map_cps_number_empty {
+            updated_map.cps_number = Set(Some(body.cps_number));
+        }
+
+        if is_map_medals_empty {
+            update_active_model_medal_times(&mut updated_map, body.medal_times);
+        }
+
+        if updated_map.is_changed() {
+            maps::Entity::update(updated_map)
+                .exec(&conn)
+                .await
+                .with_api_err()?;
         }
     } else {
         let player = player::get_or_insert(&conn, &body.author).await?;
 
-        let new_map = maps::ActiveModel {
+        let mut new_map = maps::ActiveModel {
             game_id: Set(body.map_uid),
             player_id: Set(player.id),
             name: Set(body.name),
             cps_number: Set(Some(body.cps_number)),
             ..Default::default()
         };
 
+        update_active_model_medal_times(&mut new_map, body.medal_times);
+
         maps::Entity::insert(new_map)
             .exec(&conn)
             .await

crates/game_api/tests/map_update.rs

@@ -19,6 +19,23 @@ struct Request {
     author: MapAuthor,
 }
 
+#[derive(serde::Serialize)]
+struct MedalTimes {
+    bronze_time: i32,
+    silver_time: i32,
+    gold_time: i32,
+    author_time: i32,
+}
+
+#[derive(serde::Serialize)]
+struct RequestWithMedalTimes {
+    name: String,
+    map_uid: String,
+    cps_number: u32,
+    author: MapAuthor,
+    medal_times: MedalTimes,
+}
+
 #[tokio::test]
 async fn insert_map_existing_player() -> anyhow::Result<()> {
     let player = players::ActiveModel {
@@ -166,3 +183,66 @@ async fn update_map_cps_number() -> anyhow::Result<()> {
     })
     .await
 }
+
+#[tokio::test]
+async fn update_map_medal_times() -> anyhow::Result<()> {
+    let player = players::ActiveModel {
+        id: Set(1),
+        login: Set("player_login".to_owned()),
+        name: Set("player_name".to_owned()),
+        role: Set(0),
+        ..Default::default()
+    };
+
+    let map = maps::ActiveModel {
+        id: Set(1),
+        game_id: Set("map_uid".to_owned()),
+        name: Set("map_name".to_owned()),
+        player_id: Set(1),
+        ..Default::default()
+    };
+
+    base::with_db(async |db| {
+        players::Entity::insert(player).exec(&db.sql_conn).await?;
+        maps::Entity::insert(map).exec(&db.sql_conn).await?;
+
+        let app = base::get_app(db.clone()).await;
+
+        let req = test::TestRequest::post()
+            .uri("/map/insert")
+            .set_json(RequestWithMedalTimes {
+                map_uid: "map_uid".to_owned(),
+                name: Default::default(),
+                cps_number: 5,
+                author: Default::default(),
+                medal_times: MedalTimes {
+                    bronze_time: 5000,
+                    silver_time: 4000,
+                    gold_time: 3000,
+                    author_time: 2000,
+                },
+            })
+            .to_request();
+
+        let res = test::call_service(&app, req).await;
+        assert_eq!(res.status(), 200);
+
+        let map = maps::Entity::find_by_id(1u32)
+            .one(&db.sql_conn)
+            .await?
+            .unwrap_or_else(|| panic!("Map should exist in database"));
+
+        assert_eq!(map.game_id, "map_uid");
+        assert_eq!(map.name, "map_name");
+        assert_eq!(map.player_id, 1);
+        assert_eq!(map.cps_number, Some(5));
+
+        assert_eq!(map.bronze_time, Some(5000));
+        assert_eq!(map.silver_time, Some(4000));
+        assert_eq!(map.gold_time, Some(3000));
+        assert_eq!(map.author_time, Some(2000));
+
+        anyhow::Ok(())
+    })
+    .await
+}

crates/migration/src/lib.rs

@@ -6,6 +6,7 @@ mod m20250918_132016_add_event_edition_maps_source;
 mod m20250918_135135_add_event_edition_maps_thumbnail_source;
 mod m20250918_215914_add_event_edition_maps_availability;
 mod m20250918_222203_add_event_edition_maps_disability;
+mod m20251004_214656_add_maps_medal_times;
 
 use sea_orm_migration::prelude::*;
 
@@ -25,6 +26,7 @@ impl MigratorTrait for Migrator {
             Box::new(m20250918_135135_add_event_edition_maps_thumbnail_source::Migration),
             Box::new(m20250918_215914_add_event_edition_maps_availability::Migration),
             Box::new(m20250918_222203_add_event_edition_maps_disability::Migration),
+            Box::new(m20251004_214656_add_maps_medal_times::Migration),
         ]
     }
 }

crates/migration/src/m20251004_214656_add_maps_medal_times.rs

@@ -0,0 +1,44 @@
+use sea_orm_migration::prelude::*;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(Maps::Table)
+                    .add_column(ColumnDef::new(Maps::BronzeTime).null().integer().take())
+                    .add_column(ColumnDef::new(Maps::SilverTime).null().integer().take())
+                    .add_column(ColumnDef::new(Maps::GoldTime).null().integer().take())
+                    .add_column(ColumnDef::new(Maps::AuthorTime).null().integer().take())
+                    .take(),
+            )
+            .await
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(Maps::Table)
+                    .drop_column(Maps::BronzeTime)
+                    .drop_column(Maps::SilverTime)
+                    .drop_column(Maps::GoldTime)
+                    .drop_column(Maps::AuthorTime)
+                    .take(),
+            )
+            .await
+    }
+}
+
+#[derive(DeriveIden)]
+enum Maps {
+    Table,
+    BronzeTime,
+    SilverTime,
+    GoldTime,
+    AuthorTime,
+}