puoi cancellarti ora

src/bin/client.rs

@@ -5,7 +5,7 @@ use clap::builder::NonEmptyStringValueParser;
 use lib::{client::Client, message::{Message, MessageKind}, message_read::MessageReader, player::Player};
 use crossterm::{
     cursor, event::{self, poll, Event as TermEvent, KeyCode, KeyModifiers}, execute, queue, style, terminal::{
-        disable_raw_mode, enable_raw_mode, Clear, ClearType, EnableLineWrap
+        disable_raw_mode, enable_raw_mode, Clear, ClearType, EnableLineWrap, EnterAlternateScreen
     }
 };
 
@@ -24,6 +24,22 @@ fn create_message_player(player: &Player) -> anyhow::Result<Message, anyhow::Err
     )
 }
 
+async fn delete_player(player: &Player, client: reqwest::Client, addr: &str) -> anyhow::Result<()> {
+    let player_id = &player.name;
+    let response = client
+        .get([&addr, "/delete/", &player_id].concat())
+        .send().await;
+
+    if let Err(e) = &response {
+        println!("{e}\n");
+        return Ok(())
+    }
+
+    println!("{}", response?.text().await?);
+
+    Ok(())
+}
+
 async fn send_player(player: &Player, client: reqwest::Client, addr: &str) -> anyhow::Result<()> {
     let player_message = create_message_player(&player)?;
     let response = client
@@ -37,21 +53,28 @@ async fn send_player(player: &Player, client: reqwest::Client, addr: &str) -> an
         return Ok(())
     }
 
+    println!("{}", response?.text().await?);
+
     Ok(())
 }
 async fn handle_terminal(player: &Player, stdout: &mut Stdout, client: reqwest::Client, addr: &str) -> anyhow::Result<()> {
     'handler: loop {
-        for line in HELP.split('\n') {
-            queue!(stdout, style::Print(line), cursor::MoveToNextLine(1))?;
-        }
-        stdout.flush()?;
-
         while let Ok(_event_happened) = poll(Duration::from_millis(2)) {
             match event::read().expect("diomerds") {
                 TermEvent::Key(key) => {
                     match (key.code, key.modifiers) {
                         (KeyCode::Char('c'), KeyModifiers::CONTROL) => break 'handler,
-                        (KeyCode::Char('1'), KeyModifiers::NONE) => send_player(&player, client.clone(), addr).await?,
+                        (KeyCode::Char('h'), KeyModifiers::NONE) => {
+                            for line in HELP.split('\n') {
+                                println!("{line}")
+                            }
+                        }, 
+                        (KeyCode::Char('1'), KeyModifiers::NONE) => {
+                            send_player(&player, client.clone(), addr).await?;
+                        },
+                        (KeyCode::Char('2'), KeyModifiers::NONE) => {
+                            delete_player(&player, client.clone(), addr).await?;
+                        },
                         (_, _) => println!("{:?}\n", key),
                     }
                 },
@@ -65,9 +88,6 @@ async fn handle_terminal(player: &Player, stdout: &mut Stdout, client: reqwest::
 
 #[tokio::main]
 pub async fn main() -> anyhow::Result<()> {
-    // let mut client = Client::connect("127.0.0.1", 8080).await?;
-    // let local_address = client.stream.local_addr()?;
-
     let mut stdout = std::io::stdout();
 
     enable_raw_mode()?;
@@ -77,6 +97,7 @@ pub async fn main() -> anyhow::Result<()> {
         EnableLineWrap,
         cursor::Show,
         cursor::EnableBlinking,
+        EnterAlternateScreen,
     )?;
 
     let player = Player::new()?;
@@ -84,7 +105,7 @@ pub async fn main() -> anyhow::Result<()> {
     let addr = "http://127.0.0.1:8080";
     let client = reqwest::Client::new();
 
-    println!("{}", HELP);
+    // println!("{}", HELP);
 
     handle_terminal(&player, &mut stdout, client.clone(), &addr).await?;
     disable_raw_mode()?;

src/message.rs

@@ -15,6 +15,8 @@ pub enum MessageKind {
     Move,
     CreatePlayer,
     CreateLobby,
+    DeletePlayer,
+    DeleteLobby,
 }
 
 impl Message {

src/router.rs

@@ -1,9 +1,7 @@
 use anyhow::Result;
 use axum::{
     body::Bytes, extract::{
-        rejection::JsonRejection,
+        rejection::JsonRejection, Json, Path, State
-        Json,
-        State,
     },
     http::StatusCode,
     Router
@@ -45,6 +43,10 @@ impl App {
                     let mut players = db.players
                         .lock().expect("ciao");
 
+                    if players.contains_key(&player.name) {
+                        return Err(StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS)
+                    }
+
                     players.insert(
                         player.get_name(),
                         Bytes::copy_from_slice(player.encode().expect("failed encoding player").as_ref())
@@ -58,6 +60,26 @@ impl App {
         }
     }
 
+    pub async fn delete_player(
+        State(db): State<AppState>,
+        Path(player_id): Path<String>
+    ) -> Result<axum::response::Json<Message>, StatusCode> {
+        {
+            let mut players = db.players
+                .lock().expect("ciao");
+
+            match players.contains_key(&player_id) {
+                true => {
+                    players.remove(&player_id);
+                    println!("{:?}", players);
+                    Ok(Json(Message::new("server", MessageKind::DeletePlayer, "user deleted").expect("a")))
+                },
+                false => Err(StatusCode::NOT_FOUND),
+            }
+        }
+      
+    }
+
     pub async fn create_lobby(
         State(db): State<AppState>,
         json_body: Result<Json<Message>, JsonRejection>,

src/server.rs

@@ -31,6 +31,7 @@ impl Server {
             .route("/echo", post(App::echo))
             .route("/create/player", post(App::create_player))
             .route("/create/lobby", post(App::create_lobby))
+            .route("/delete/{player-id}", get(App::delete_player))
             .with_state(app.db);
 
         axum::serve(listener, router).await.unwrap();