async registration working

client/src/modes/handlers/event.rs

@@ -45,6 +45,7 @@ use crate::config::binds::key_sequences::KeySequenceTracker;
 use tokio::spawn;
 use tokio::sync::mpsc;
 use crate::tui::functions::common::login::LoginResult;
+use crate::tui::functions::common::register::RegisterResult;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum EventOutcome {
@@ -65,10 +66,14 @@ pub struct EventHandler {
     pub key_sequence_tracker: KeySequenceTracker,
     pub auth_client: AuthClient,
     pub login_result_sender: mpsc::Sender<LoginResult>,
+    pub register_result_sender: mpsc::Sender<RegisterResult>,
 }
 
 impl EventHandler {
-    pub async fn new(login_result_sender: mpsc::Sender<LoginResult>) -> Result<Self> {
+    pub async fn new(
+        login_result_sender: mpsc::Sender<LoginResult>,
+        register_result_sender: mpsc::Sender<RegisterResult>,
+    ) -> Result<Self> {
         Ok(EventHandler {
             command_mode: false,
             command_input: String::new(),
@@ -80,6 +85,7 @@ impl EventHandler {
             key_sequence_tracker: KeySequenceTracker::new(800),
             auth_client: AuthClient::new().await?,
             login_result_sender,
+            register_result_sender,
         })
     }
 
@@ -279,11 +285,56 @@ impl EventHandler {
                                     login_action_message
                                 }
                                 UiContext::Register => {
-                                    match index {
-                                        0 => register::save(register_state, &mut self.auth_client, app_state).await.context("Register save action failed")?,
+                                    let register_action_message = match index {
+                                        0 => { // "Register" button pressed
+                                            // Clone necessary data
+                                            let username = register_state.username.clone();
+                                            let email = register_state.email.clone();
+                                            let password = register_state.password.clone();
+                                            let password_confirmation = register_state.password_confirmation.clone();
+                                            let role = register_state.role.clone();
+
+                                            // 1. Client-side validation (similar to register::save)
+                                            if username.trim().is_empty() {
+                                                app_state.show_dialog("Registration Failed", "Username cannot be empty.", vec!["OK".to_string()], DialogPurpose::RegisterFailed);
+                                                "Username cannot be empty.".to_string()
+                                            } else if !password.is_empty() && password != password_confirmation {
+                                                 app_state.show_dialog("Registration Failed", "Passwords do not match.", vec!["OK".to_string()], DialogPurpose::RegisterFailed);
+                                                 "Passwords do not match.".to_string()
+                                            } else {
+                                                // 2. Show Loading Dialog
+                                                app_state.show_loading_dialog("Registering", "Please wait...");
+
+                                                // 3. Clone sender for the task
+                                                let sender = self.register_result_sender.clone();
+
+                                                // 4. Spawn the registration task
+                                                spawn(async move {
+                                                    let register_outcome = match AuthClient::new().await {
+                                                        Ok(mut auth_client) => {
+                                                            // Handle optional fields correctly for the gRPC call
+                                                            let password_opt = if password.is_empty() { None } else { Some(password) };
+                                                            let password_conf_opt = if password_confirmation.is_empty() { None } else { Some(password_confirmation) };
+                                                            let role_opt = if role.is_empty() { None } else { Some(role) };
+
+                                                            match auth_client.register(username.clone(), email, password_opt, password_conf_opt, role_opt).await {
+                                                                Ok(response) => register::RegisterResult::Success(response),
+                                                                Err(e) => register::RegisterResult::Failure(format!("{}", e)),
+                                                            }
+                                                        }
+                                                        Err(e) => register::RegisterResult::ConnectionError(format!("Failed to create AuthClient: {}", e)),
+                                                    };
+                                                    let _ = sender.send(register_outcome).await;
+                                                });
+
+                                                // 5. Return immediately
+                                                "Registration initiated.".to_string()
+                                            }
+                                        },
                                         1 => register::back_to_login(register_state, app_state, buffer_state).await,
                                         _ => "Invalid Login Option".to_string(),
-                                    }
+                                    };
+                                    register_action_message
                                 }
                                 UiContext::Admin => {
                                     admin::handle_admin_selection(app_state, admin_state);