feat: possible rounds display

Author: filipton

src/github/mod.rs

@@ -6,9 +6,7 @@ const GITHUB_API_URL: &str = "https://api.github.com";
 const GH_OWNER: &str = "FKMTime";
 const GH_REPO: &str = "firmware";
 
-pub async fn get_releases(
-    client: &reqwest::Client,
-) -> Result<Vec<structs::ReleaseAssetItem>> {
+pub async fn get_releases(client: &reqwest::Client) -> Result<Vec<structs::ReleaseAssetItem>> {
     let url = format!("{GITHUB_API_URL}/repos/{GH_OWNER}/{GH_REPO}/releases");
 
     let res = client

src/handler.rs

@@ -106,23 +106,15 @@ async fn send_device_status(
 ) -> Result<()> {
     let state = state.inner.read().await;
     let settings = state.devices_settings.get(&esp_connect_info.id);
-    let frame = if let Some(settings) = settings {
+    let frame = if let Some(_settings) = settings {
         TimerPacket {
             tag: None,
-            data: TimerPacketInner::DeviceSettings {
-                use_inspection: settings.use_inspection,
-                secondary_text: settings.secondary_text.clone(),
-                added: true,
-            },
+            data: TimerPacketInner::DeviceSettings { added: true },
         }
     } else {
         TimerPacket {
             tag: None,
-            data: TimerPacketInner::DeviceSettings {
-                use_inspection: false,
-                secondary_text: "".to_string(),
-                added: false,
-            },
+            data: TimerPacketInner::DeviceSettings { added: false },
         }
     };
 
@@ -217,6 +209,7 @@ async fn on_timer_response(
                             country_iso2: info.country_iso2.unwrap_or_default(),
                             display: format!("{}{}", info.name, registrant_display),
                             can_compete: info.can_compete,
+                            possible_rounds: info.possible_rounds,
                         },
                     };
 
@@ -243,8 +236,9 @@ async fn on_timer_response(
             session_id,
             delegate,
             inspection_time,
+            round_id,
         } => {
-            trace!("Solve: {solve_time} ({penalty}) {competitor_id} {esp_id} {timestamp} {session_id} {delegate}");
+            trace!("Solve: {solve_time} ({penalty}) {competitor_id} {esp_id} {timestamp} {session_id} {delegate} {round_id}");
 
             let res = crate::socket::api::send_solve_entry(
                 solve_time,
@@ -256,6 +250,7 @@ async fn on_timer_response(
                 delegate,
                 &session_id,
                 inspection_time,
+                &round_id,
             )
             .await;
 

src/socket/api.rs

@@ -1,5 +1,9 @@
 use anyhow::Result;
-use unix_utils::{request::UnixRequestData, response::UnixResponseData, SnapshotData, UnixError};
+use unix_utils::{
+    request::UnixRequestData,
+    response::{PossibleRound, UnixResponseData},
+    SnapshotData, UnixError,
+};
 
 #[derive(Debug)]
 #[allow(dead_code)]
@@ -11,6 +15,7 @@ pub struct CompetitorInfo {
     pub country_iso2: Option<String>,
     pub gender: String,
     pub can_compete: bool,
+    pub possible_rounds: Vec<PossibleRound>,
 }
 
 pub async fn get_competitor_info(card_id: u64) -> Result<CompetitorInfo, UnixError> {
@@ -28,6 +33,7 @@ pub async fn get_competitor_info(card_id: u64) -> Result<CompetitorInfo, UnixErr
         country_iso2,
         gender,
         can_compete,
+        possible_rounds,
     } = res
     {
         return Ok(CompetitorInfo {
@@ -38,6 +44,26 @@ pub async fn get_competitor_info(card_id: u64) -> Result<CompetitorInfo, UnixErr
             country_iso2,
             gender,
             can_compete,
+            possible_rounds: possible_rounds.unwrap_or(
+                [
+                    PossibleRound {
+                        id: "333-r1".to_string(),
+                        name: "3x3 R1".to_string(),
+                        use_inspection: true,
+                    },
+                    PossibleRound {
+                        id: "222-r1".to_string(),
+                        name: "2x2 R1".to_string(),
+                        use_inspection: true,
+                    },
+                    PossibleRound {
+                        id: "other".to_string(),
+                        name: "Other room".to_string(),
+                        use_inspection: false,
+                    },
+                ]
+                .to_vec(),
+            ),
         });
     }
 
@@ -84,6 +110,7 @@ pub async fn send_solve_entry(
     is_delegate: bool,
     session_id: &str,
     inspection_time: i64,
+    round_id: &str,
 ) -> Result<(), UnixError> {
     let solved_at = chrono::DateTime::from_timestamp_millis(solved_at as i64 * 1000)
         .ok_or_else(|| UnixError {
@@ -103,6 +130,7 @@ pub async fn send_solve_entry(
         is_delegate,
         session_id: session_id.to_string(),
         inspection_time,
+        round_id: round_id.to_string(),
     };
 
     let res = crate::UNIX_SOCKET

src/socket/mod.rs

@@ -204,10 +204,7 @@ async fn process_untagged_response(data: UnixResponseData) -> Result<()> {
 
             let mut devices = Vec::new();
             for room in status.rooms {
-                let room_settings = crate::structs::CompetitionDeviceSettings {
-                    use_inspection: room.use_inspection,
-                    secondary_text: room.secondary_text.clone(),
-                };
+                let room_settings = crate::structs::CompetitionDeviceSettings {};
 
                 for device in room.devices {
                     devices.push(device);

src/structs.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use unix_utils::{SnapshotData, TestPacketData};
+use unix_utils::{response::PossibleRound, SnapshotData, TestPacketData};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct TimerPacket {
@@ -28,6 +28,7 @@ pub enum TimerPacketInner {
         session_id: String, // UUID
         delegate: bool,
         inspection_time: i64,
+        round_id: String,
     },
     SolveConfirm {
         competitor_id: u64,
@@ -57,11 +58,10 @@ pub enum TimerPacketInner {
         display: String,
         country_iso2: String,
         can_compete: bool,
+        possible_rounds: Vec<PossibleRound>,
     },
     AttendanceMarked,
     DeviceSettings {
-        use_inspection: bool,
-        secondary_text: String,
         added: bool,
     },
     Logs {
@@ -105,10 +105,7 @@ pub struct AppState {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct CompetitionDeviceSettings {
-    pub use_inspection: bool,
-    pub secondary_text: String,
-}
+pub struct CompetitionDeviceSettings {}
 
 impl SharedAppState {
     pub async fn new(dev_mode: bool) -> Self {

src/updater.rs

@@ -102,7 +102,9 @@ pub async fn update_client(
     };
 
     socket
-        .send(Message::Text(serde_json::to_string(&start_update_resp)?.into()))
+        .send(Message::Text(
+            serde_json::to_string(&start_update_resp)?.into(),
+        ))
         .await?;
 
     // wait for esp to respond

unix-utils/Cargo.lock

@@ -32,6 +32,7 @@ pub enum UnixRequestData {
         is_delegate: bool,
         session_id: String,
         inspection_time: i64,
+        round_id: String,
     },
     UpdateBatteryPercentage {
         esp_id: u32,

unix-utils/src/request.rs

@@ -28,6 +28,7 @@ pub enum UnixResponseData {
         country_iso2: Option<String>,
         gender: String,
         can_compete: bool,
+        possible_rounds: Option<Vec<PossibleRound>>, // TODO: remove option,
     },
     Error {
         message: String,
@@ -60,11 +61,16 @@ pub struct CompetitionStatusResp {
 pub struct Room {
     pub id: String,
     pub name: String,
-    pub secondary_text: String,
-    pub use_inspection: bool,
     pub devices: Vec<u32>,
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
+pub struct PossibleRound {
+    pub id: String,
+    pub name: String,
+    pub use_inspection: bool,
+}
+
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct WifiSettings {