misc: more generic set & gets

src/main.rs

@@ -187,39 +187,32 @@ async fn handle_connection(
                                 error!("handle_tournament_cancel: {}", e);
                                 let _ = send(&tx, e.to_string().as_str());
                             }
-                        } else if parts.get(1) == Some(&"WAIT") && parts.len() > 2 {
-                            match parts[2].parse::<f64>() {
-                                Ok(new_timeout) => {
-                                    if let Err(e) =
-                                        sd.handle_tournament_wait(addr, new_timeout).await
-                                    {
-                                        error!("handle_tournament_wait: {}", e);
-                                        let _ = send(&tx, e.to_string().as_str());
-                                    }
-                                }
-                                Err(_) => {
-                                    let _ = send(&tx, "ERROR:INVALID:TOURNAMENT");
-                                }
-                            }
                         } else {
                             let _ = send(&tx, "ERROR:INVALID:TOURNAMENT");
                         }
                     }
                     "GET" => {
-                        if parts.get(1) == Some(&"MOVE_WAIT") {
+                        if let Some(data_id) = parts.get(1) {	
-                            if let Err(e) = sd.handle_get_move_wait(tx.clone()).await {
+                            if let Err(e) = sd.handle_get_data(tx.clone(), data_id.to_string()).await {
-                                error!("handle_get_move_wait: {}", e);
+                                error!("handle_get_data: {}", e);
-                                let _ = send(&tx, e.to_string().as_str());
-                            }
-                        } else if parts.get(1) == Some(&"TOURNAMENT_STATUS") {
-                            if let Err(e) = sd.handle_get_tournament_status(tx.clone()).await {
-                                error!("handle_get_tournament_status: {}", e);
                                 let _ = send(&tx, e.to_string().as_str());
                             }
                         } else {
                             let _ = send(&tx, "ERROR:INVALID:GET");
                         }
                     }
+					"SET" => {
+						if parts.len() > 2 {
+							let data_id = parts[1].to_string();
+							let data_value = parts[2].to_string();
+							if let Err(e) = sd.handle_set_data(tx.clone(), addr, data_id, data_value).await {
+								error!("handle_set_data: {}", e);
+								let _ = send(&tx, e.to_string().as_str());
+							}
+						} else {
+							let _ = send(&tx, "ERROR:INVALID:SET");
+						}
+					}
                     _ => {
                         let _ = send(&tx, "ERROR:UNKNOWN");
                     }

src/server.rs

@@ -604,71 +604,66 @@ impl Server {
         Ok(())
     }
 
-    pub async fn handle_tournament_wait(
+    pub async fn handle_get_data(
         &self,
+        tx: UnboundedSender<Message>,
+        data_id: String,
+    ) -> Result<(), anyhow::Error> {
+        let mut msg = format!("GET:{}:", data_id);
+        match data_id.as_str() {
+            "TOURNAMENT_STATUS" => {
+                let tournament = self.tournament.read().await.clone();
+                if tournament.is_some() {
+                    msg += tournament.as_ref().unwrap().read().await.get_type().as_str();
+                } else {
+                    msg += "false";
+                }
+            }
+            "MOVE_WAIT" => {
+                let wait_time = *self.waiting_timeout.read().await as f64 / 1000f64;
+                msg += wait_time.to_string().as_str();
+            }
+            "DEMO_MODE" => {
+                let demo_mode = *self.demo_mode.read().await;
+                msg += demo_mode.to_string().as_str();
+            }
+            &_ => return Err(anyhow::anyhow!("ERROR:INVALID:GET")),
+        }
+
+        let _ = send(&tx, &msg);
+        Ok(())
+    }
+
+    pub async fn handle_set_data(
+        &self,
+        tx: UnboundedSender<Message>,
         addr: SocketAddr,
-        new_timeout: f64,
+        data_id: String,
+        data_value: String,
     ) -> Result<(), anyhow::Error> {
         if !self.auth_check(addr).await {
             return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
         }
 
-        *self.waiting_timeout.write().await = (new_timeout * 1000.0) as u64;
+        match data_id.as_str() {
-        Ok(())
+            "DEMO_MODE" => {
-    }
+                let demo_mode = data_value.parse::<bool>();
-
+                if demo_mode.is_err() {
-    pub async fn handle_get_move_wait(
+                    return Err(anyhow::anyhow!("ERROR:INVALID:SET"));
-        &self,
+                }
-        tx: UnboundedSender<Message>,
+                *self.demo_mode.write().await = demo_mode.unwrap();
-    ) -> Result<(), anyhow::Error> {
+            }
-        let mut msg = "GET:MOVE_WAIT:".to_string();
+            "MOVE_WAIT" => {
-        msg += &(*self.waiting_timeout.read().await as f64 / 1000f64).to_string();
+                let wait_time = data_value.parse::<f64>();
-        let _ = send(&tx, &msg);
+                if wait_time.is_err() {
-        Ok(())
+                    return Err(anyhow::anyhow!("ERROR:INVALID:SET"));
-    }
+                }
-
+                *self.waiting_timeout.write().await = (wait_time.unwrap() * 1000.0) as u64;
-    pub async fn handle_get_tournament_status(
+            }
-        &self,
+            &_ => return Err(anyhow::anyhow!("ERROR:INVALID:SET")),
-        tx: UnboundedSender<Message>,
-    ) -> Result<(), anyhow::Error> {
-        let status = self.tournament.read().await.is_some();
-        let mut msg = "GET:TOURNAMENT_STATUS:".to_string();
-        if status {
-            msg += self.tournament.read().await.as_ref().unwrap().read().await.get_type().as_str();
-        } else {
-            msg += status.to_string().as_str();
-        }
-        let _ = send(&tx, &msg);
-        Ok(())
-    }
-
-    pub async fn handle_get_demo_mode(
-        &self,
-        tx: UnboundedSender<Message>,
-    ) -> Result<(), anyhow::Error> {
-        let demo_mode = *self.demo_mode.read().await;
-        let mut msg = "GET:DEMO_MODE:".to_string();
-        msg += demo_mode.to_string().as_str();
-        let _ = send(&tx, &msg);
-        Ok(())
-    }
-
-    pub async fn handle_set_demo_mode(
-        &self,
-        tx: UnboundedSender<Message>,
-        addr: SocketAddr,
-        demo_mode: bool,
-    ) -> Result<(), anyhow::Error> {
-        if !self.auth_check(addr).await {
-            return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
         }
 
-        if self.tournament.read().await.is_some() {
+        let _ = send(&tx, &format!("SET:{}:ACK", data_id));
-            return Err(anyhow::anyhow!("ERROR:INVALID:TOURNAMENT"));
-        }
-
-        *self.demo_mode.write().await = demo_mode;
-        let _ = send(&tx, "SET:DEMO_MODE:ACK");
         Ok(())
     }