244 lines
8.2 KiB
Rust
244 lines
8.2 KiB
Rust
// src/pages/login/logic.rs
|
||
|
||
use crate::services::auth::AuthClient;
|
||
use crate::state::pages::auth::AuthState;
|
||
use crate::state::app::state::AppState;
|
||
use crate::buffer::state::{AppView, BufferState};
|
||
use crate::config::storage::storage::{StoredAuthData, save_auth_data};
|
||
use crate::ui::handlers::context::DialogPurpose;
|
||
use common::proto::komp_ac::auth::LoginResponse;
|
||
use crate::pages::login::LoginFormState;
|
||
use crate::state::pages::auth::UserRole;
|
||
use canvas::DataProvider;
|
||
use anyhow::{Context, Result, anyhow};
|
||
use tokio::spawn;
|
||
use tokio::sync::mpsc;
|
||
use tracing::{info, error};
|
||
|
||
#[derive(Debug)]
|
||
pub enum LoginResult {
|
||
Success(LoginResponse),
|
||
Failure(String),
|
||
ConnectionError(String),
|
||
}
|
||
|
||
/// Attempts to log the user in using the provided credentials via gRPC.
|
||
/// Updates AuthState and AppState on success or failure.
|
||
pub async fn save(
|
||
auth_state: &mut AuthState,
|
||
login_state: &mut LoginFormState,
|
||
auth_client: &mut AuthClient,
|
||
app_state: &mut AppState,
|
||
) -> Result<String> {
|
||
let identifier = login_state.username().to_string();
|
||
let password = login_state.password().to_string();
|
||
|
||
// --- Client-side validation ---
|
||
if identifier.trim().is_empty() {
|
||
let error_message = "Username/Email cannot be empty.".to_string();
|
||
app_state.show_dialog(
|
||
"Login Failed",
|
||
&error_message,
|
||
vec!["OK".to_string()],
|
||
DialogPurpose::LoginFailed,
|
||
);
|
||
login_state.set_error_message(Some(error_message.clone()));
|
||
return Err(anyhow!(error_message));
|
||
}
|
||
|
||
// Clear previous error/dialog state before attempting
|
||
login_state.set_error_message(None);
|
||
app_state.hide_dialog();
|
||
|
||
// Call the gRPC login method
|
||
match auth_client.login(identifier.clone(), password).await
|
||
.with_context(|| format!("gRPC login attempt failed for identifier: {}", identifier))
|
||
{
|
||
Ok(response) => {
|
||
// Store authentication details
|
||
auth_state.auth_token = Some(response.access_token.clone());
|
||
auth_state.user_id = Some(response.user_id.clone());
|
||
auth_state.role = Some(UserRole::from_str(&response.role));
|
||
auth_state.decoded_username = Some(response.username.clone());
|
||
|
||
login_state.set_has_unsaved_changes(false);
|
||
login_state.set_error_message(None);
|
||
|
||
let success_message = format!(
|
||
"Login Successful!\n\n\
|
||
Username: {}\n\
|
||
User ID: {}\n\
|
||
Role: {}",
|
||
response.username,
|
||
response.user_id,
|
||
response.role
|
||
);
|
||
|
||
app_state.show_dialog(
|
||
"Login Success",
|
||
&success_message,
|
||
vec!["Menu".to_string(), "Exit".to_string()],
|
||
DialogPurpose::LoginSuccess,
|
||
);
|
||
|
||
login_state.username_mut().clear();
|
||
login_state.password_mut().clear();
|
||
login_state.set_current_cursor_pos(0);
|
||
|
||
Ok("Login successful, details shown in dialog.".to_string())
|
||
}
|
||
Err(e) => {
|
||
let error_message = format!("{}", e);
|
||
app_state.show_dialog(
|
||
"Login Failed",
|
||
&error_message,
|
||
vec!["OK".to_string()],
|
||
DialogPurpose::LoginFailed,
|
||
);
|
||
login_state.set_error_message(Some(error_message.clone()));
|
||
login_state.set_has_unsaved_changes(true);
|
||
login_state.username_mut().clear();
|
||
login_state.password_mut().clear();
|
||
Err(e)
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Reverts the login form fields to empty and returns to the previous screen (Intro).
|
||
pub async fn revert(
|
||
login_state: &mut LoginFormState,
|
||
app_state: &mut AppState,
|
||
) -> String {
|
||
// Clear the underlying state
|
||
login_state.clear();
|
||
|
||
// Also clear values inside the editor’s data provider
|
||
{
|
||
let dp = login_state.editor.data_provider_mut();
|
||
dp.set_field_value(0, "".to_string());
|
||
dp.set_field_value(1, "".to_string());
|
||
dp.set_current_field(0);
|
||
dp.set_current_cursor_pos(0);
|
||
dp.set_has_unsaved_changes(false);
|
||
}
|
||
|
||
app_state.hide_dialog();
|
||
"Login reverted".to_string()
|
||
}
|
||
|
||
/// Clears login form and navigates back to main menu.
|
||
pub async fn back_to_main(
|
||
login_state: &mut LoginFormState,
|
||
app_state: &mut AppState,
|
||
buffer_state: &mut BufferState,
|
||
) -> String {
|
||
login_state.clear();
|
||
app_state.hide_dialog();
|
||
|
||
buffer_state.close_active_buffer();
|
||
buffer_state.update_history(AppView::Intro);
|
||
|
||
"Returned to main menu".to_string()
|
||
}
|
||
|
||
/// Validates input, shows loading, and spawns the login task.
|
||
pub fn initiate_login(
|
||
login_state: &mut LoginFormState,
|
||
app_state: &mut AppState,
|
||
mut auth_client: AuthClient,
|
||
sender: mpsc::Sender<LoginResult>,
|
||
) -> String {
|
||
login_state.sync_from_editor();
|
||
let username = login_state.username().to_string();
|
||
let password = login_state.password().to_string();
|
||
|
||
if username.trim().is_empty() {
|
||
app_state.show_dialog(
|
||
"Login Failed",
|
||
"Username/Email cannot be empty.",
|
||
vec!["OK".to_string()],
|
||
DialogPurpose::LoginFailed,
|
||
);
|
||
"Username cannot be empty.".to_string()
|
||
} else {
|
||
app_state.show_loading_dialog("Logging In", "Please wait...");
|
||
|
||
spawn(async move {
|
||
let login_outcome = match auth_client.login(username.clone(), password).await
|
||
.with_context(|| format!("Spawned login task failed for identifier: {}", username))
|
||
{
|
||
Ok(response) => LoginResult::Success(response),
|
||
Err(e) => LoginResult::Failure(format!("{}", e)),
|
||
};
|
||
if let Err(e) = sender.send(login_outcome).await {
|
||
error!("Failed to send login result: {}", e);
|
||
}
|
||
});
|
||
|
||
"Login initiated.".to_string()
|
||
}
|
||
}
|
||
|
||
/// Handles the result received from the login task.
|
||
/// Returns true if a redraw is needed.
|
||
pub fn handle_login_result(
|
||
result: LoginResult,
|
||
app_state: &mut AppState,
|
||
auth_state: &mut AuthState,
|
||
login_state: &mut LoginFormState,
|
||
) -> bool {
|
||
match result {
|
||
LoginResult::Success(response) => {
|
||
auth_state.auth_token = Some(response.access_token.clone());
|
||
auth_state.user_id = Some(response.user_id.clone());
|
||
auth_state.role = Some(UserRole::from_str(&response.role));
|
||
auth_state.decoded_username = Some(response.username.clone());
|
||
|
||
let data_to_store = StoredAuthData {
|
||
access_token: response.access_token.clone(),
|
||
user_id: response.user_id.clone(),
|
||
role: response.role.clone(),
|
||
username: response.username.clone(),
|
||
};
|
||
if let Err(e) = save_auth_data(&data_to_store) {
|
||
error!("Failed to save auth data to file: {}", e);
|
||
}
|
||
|
||
let success_message = format!(
|
||
"Login Successful!\n\nUsername: {}\nUser ID: {}\nRole: {}",
|
||
response.username, response.user_id, response.role
|
||
);
|
||
app_state.update_dialog_content(
|
||
&success_message,
|
||
vec!["Menu".to_string(), "Exit".to_string()],
|
||
DialogPurpose::LoginSuccess,
|
||
);
|
||
info!(message = %success_message, "Login successful");
|
||
}
|
||
LoginResult::Failure(err_msg) | LoginResult::ConnectionError(err_msg) => {
|
||
app_state.update_dialog_content(
|
||
&err_msg,
|
||
vec!["OK".to_string()],
|
||
DialogPurpose::LoginFailed,
|
||
);
|
||
login_state.set_error_message(Some(err_msg.clone()));
|
||
error!(error = %err_msg, "Login failed/connection error");
|
||
}
|
||
}
|
||
|
||
login_state.username_mut().clear();
|
||
login_state.password_mut().clear();
|
||
login_state.set_has_unsaved_changes(false);
|
||
login_state.set_current_cursor_pos(0);
|
||
|
||
true
|
||
}
|
||
|
||
pub async fn handle_action(action: &str) -> Result<String> {
|
||
match action {
|
||
"previous_entry" => Ok("Previous entry not implemented".into()),
|
||
"next_entry" => Ok("Next entry not implemented".into()),
|
||
_ => Err(anyhow!("Unknown login action: {}", action)),
|
||
}
|
||
}
|