Attempting to fix sendplayer

src/main.rs

@@ -27,6 +27,7 @@ async fn main() -> session_rs::Result<()> {
                 Box::pin(async move {
                     println!("Connected");
                     let uuid = Arc::new(Mutex::new(String::new()));
+                    let name = Arc::new(Mutex::new(String::new()));
 
                     session
                         .on_close({
@@ -63,13 +64,15 @@ async fn main() -> session_rs::Result<()> {
                         .on_request::<methods::Auth, _>({
                             let pool = Arc::clone(&pool);
                             let uuid = Arc::clone(&uuid);
+                            let sessions = Arc::clone(&sessions);
+                            let name = Arc::clone(&name);
                             let session = session.clone();
-                            let sessions = sessions.clone();
 
                             move |_, token| {
                                 methods::auth::authenticate(
                                     sessions.clone(),
                                     session.clone(),
+                                    name.clone(),
                                     uuid.clone(),
                                     token,
                                     pool.clone(),
@@ -188,9 +191,16 @@ async fn main() -> session_rs::Result<()> {
                             let sessions = Arc::clone(&sessions);
                             let pool = Arc::clone(&pool);
                             let uuid = Arc::clone(&uuid);
+                            let name = Arc::clone(&name);
 
                             move |_, targets| {
-                                methods::user::send_user(sessions.clone(), uuid.clone(), targets.clone(), pool.clone())
+                                methods::user::send_user(
+                                    sessions.clone(),
+                                    name.clone(),
+                                    uuid.clone(),
+                                    targets.targets.clone(),
+                                    pool.clone(),
+                                )
                             }
                         })
                         .await;

src/methods/auth.rs

@@ -11,6 +11,7 @@ use crate::{
 pub async fn authenticate(
     sessions: SessionMap,
     session: Session,
+    name: UUID,
     uuid: UUID,
     session_token: String,
     pool: Arc<SqlitePool>,
@@ -41,6 +42,7 @@ pub async fn authenticate(
         .map_err(|_| "Unable to parse auth response".to_string())?;
 
     *uuid.lock().await = auth.id.clone();
+    *name.lock().await = auth.name.clone();
 
     sessions
         .lock()

src/methods/mod.rs

@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 use session_rs::Method;
 
 use crate::{
-    types::{EmoteRequest, EventEmote},
+    types::{EmoteRequest, EventEmote, PlayerStream},
     user::User,
 };
 
@@ -84,7 +84,7 @@ impl Method for EmoteEvent {
 pub struct GetPlayer;
 
 impl Method for GetPlayer {
-    const NAME: &'static str = "player";
+    const NAME: &'static str = "get_player";
     type Request = String;
     type Response = Option<User>;
     type Error = String;
@@ -95,7 +95,7 @@ pub struct Player;
 
 impl Method for Player {
     const NAME: &'static str = "player";
-    type Request = User;
+    type Request = PlayerStream;
     type Response = ();
     type Error = ();
 }
@@ -103,9 +103,14 @@ impl Method for Player {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SendPlayer;
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SendPlayerRequest {
+    pub targets: Vec<String>,
+}
+
 impl Method for SendPlayer {
     const NAME: &'static str = "send_player";
-    type Request = Vec<String>;
+    type Request = SendPlayerRequest;
     type Response = ();
     type Error = String;
 }

src/methods/user.rs

@@ -4,7 +4,7 @@ use sqlx::SqlitePool;
 
 use crate::{
     methods,
-    types::{SessionMap, UUID},
+    types::{PlayerStream, SessionMap, UUID},
     user::User,
 };
 
@@ -22,11 +22,20 @@ pub async fn get_user(
 
 pub async fn send_user(
     sessions: SessionMap,
+    name: UUID,
     uuid: UUID,
     targets: Vec<String>,
     pool: Arc<SqlitePool>,
 ) -> Result<(), String> {
-    let user = crate::user::get(&uuid.lock().await, pool.as_ref()).await?;
+    let user = PlayerStream {
+        player: crate::user::get(&uuid.lock().await, pool.as_ref()).await?,
+        uuid: uuid.lock().await.clone(),
+        name: name.lock().await.clone(),
+    };
+
+    println!("{user:?}");
+
+    println!("{targets:?}");
 
     for target in targets {
         if let Some(sessions) = sessions.lock().await.get_mut(&target) {

src/types.rs

@@ -7,6 +7,8 @@ use std::{
     sync::Arc,
 };
 
+use crate::user::User;
+
 pub type SessionMap = Arc<Mutex<HashMap<String, HashSet<Session>>>>;
 pub type UUID = Arc<Mutex<String>>;
 
@@ -29,3 +31,10 @@ pub struct EventEmote {
     pub emote: String,
     pub from: String,
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PlayerStream {
+    pub player: User,
+    pub uuid: String,
+    pub name: String,
+}