use anyhow::Error as AuthError;
use serde::{Deserialize, Serialize};
use crate::messages::AuthMessage;
use crate::status::{AuthDenyReason, auth_deny_message};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum LoginErrorCode {
#[default]
None,
RateLimited,
CredentialsInvalid,
AccountDenied,
TwoFactorRequired,
TwoFactorInvalid,
TwoFactorExpired,
TwoFactorMissing,
TwoFactorUnavailable,
TwoFactorDisabled,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LoginFeedbackVariant {
Success,
Info,
Error,
}
pub trait LoginOutcomeFeedback {
fn success(&self) -> bool;
fn requires_two_factor(&self) -> bool;
fn error_code(&self) -> LoginErrorCode;
fn message(&self) -> Option<&AuthMessage>;
fn deny_reason(&self) -> Option<&AuthDenyReason>;
}
#[derive(Clone, Debug)]
pub struct LoginFeedbackMessages {
pub rate_limited: AuthMessage,
pub credentials_invalid: AuthMessage,
pub account_denied: AuthMessage,
pub two_factor_required: AuthMessage,
pub two_factor_invalid: AuthMessage,
pub two_factor_expired: AuthMessage,
pub two_factor_missing: AuthMessage,
pub two_factor_unavailable: AuthMessage,
pub two_factor_disabled: AuthMessage,
pub success: AuthMessage,
}
impl LoginFeedbackMessages {
pub fn default_messages() -> Self {
Self {
rate_limited: AuthMessage::from_static("auth.login.feedback.rate_limited"),
credentials_invalid: AuthMessage::from_static(
"auth.login.feedback.credentials_invalid",
),
account_denied: AuthMessage::from_static("auth.access.denied.unknown"),
two_factor_required: AuthMessage::from_static(
"auth.login.feedback.two_factor_required",
),
two_factor_invalid: AuthMessage::from_static("auth.login.feedback.two_factor_invalid"),
two_factor_expired: AuthMessage::from_static("auth.login.feedback.two_factor_expired"),
two_factor_missing: AuthMessage::from_static("auth.login.feedback.two_factor_missing"),
two_factor_unavailable: AuthMessage::from_static(
"auth.login.feedback.two_factor_unavailable",
),
two_factor_disabled: AuthMessage::from_static(
"auth.login.feedback.two_factor_disabled",
),
success: AuthMessage::from_static("auth.login.feedback.success"),
}
}
#[cfg(test)]
pub(crate) fn test_messages() -> Self {
Self {
rate_limited: AuthMessage::from_static("rate_limited"),
credentials_invalid: AuthMessage::from_static("credentials_invalid"),
account_denied: AuthMessage::from_static("account_denied"),
two_factor_required: AuthMessage::from_static("two_factor_required"),
two_factor_invalid: AuthMessage::from_static("two_factor_invalid"),
two_factor_expired: AuthMessage::from_static("two_factor_expired"),
two_factor_missing: AuthMessage::from_static("two_factor_missing"),
two_factor_unavailable: AuthMessage::from_static("two_factor_unavailable"),
two_factor_disabled: AuthMessage::from_static("two_factor_disabled"),
success: AuthMessage::from_static("success"),
}
}
}
pub fn derive_login_feedback<T: LoginOutcomeFeedback>(
outcome: &T,
) -> Option<(AuthMessage, LoginFeedbackVariant)> {
let messages = LoginFeedbackMessages::default_messages();
if outcome.error_code() == LoginErrorCode::AccountDenied {
let variant = if outcome.requires_two_factor() {
LoginFeedbackVariant::Info
} else {
LoginFeedbackVariant::Error
};
let message = outcome
.deny_reason()
.map(auth_deny_message)
.unwrap_or_else(|| messages.account_denied.clone());
return Some((message, variant));
}
derive_login_feedback_with_messages(&messages, outcome)
}
pub fn derive_login_feedback_with_messages<T: LoginOutcomeFeedback>(
messages: &LoginFeedbackMessages,
outcome: &T,
) -> Option<(AuthMessage, LoginFeedbackVariant)> {
if outcome.success() && !outcome.requires_two_factor() {
return None;
}
let variant = if outcome.requires_two_factor() {
LoginFeedbackVariant::Info
} else {
LoginFeedbackVariant::Error
};
let message = match outcome.error_code() {
LoginErrorCode::RateLimited => messages.rate_limited.clone(),
LoginErrorCode::CredentialsInvalid => messages.credentials_invalid.clone(),
LoginErrorCode::AccountDenied => messages.account_denied.clone(),
LoginErrorCode::TwoFactorRequired => messages.two_factor_required.clone(),
LoginErrorCode::TwoFactorInvalid => messages.two_factor_invalid.clone(),
LoginErrorCode::TwoFactorExpired => messages.two_factor_expired.clone(),
LoginErrorCode::TwoFactorMissing => messages.two_factor_missing.clone(),
LoginErrorCode::TwoFactorUnavailable => messages.two_factor_unavailable.clone(),
LoginErrorCode::TwoFactorDisabled => messages.two_factor_disabled.clone(),
LoginErrorCode::None => outcome.message()?.clone(),
};
Some((message, variant))
}
pub fn login_feedback_from_result<T: LoginOutcomeFeedback>(
result: &Result<T, AuthError>,
) -> Option<(AuthMessage, LoginFeedbackVariant)> {
let messages = LoginFeedbackMessages::default_messages();
login_feedback_from_result_with_messages(&messages, result)
}
pub fn login_feedback_from_result_with_messages<T: LoginOutcomeFeedback>(
messages: &LoginFeedbackMessages,
result: &Result<T, AuthError>,
) -> Option<(AuthMessage, LoginFeedbackVariant)> {
match result {
Ok(outcome) => derive_login_feedback_with_messages(messages, outcome),
Err(_error) => Some((
AuthMessage::from_static("auth.server_error"),
LoginFeedbackVariant::Error,
)),
}
}
#[cfg(test)]
mod tests {
use super::{
LoginErrorCode, LoginFeedbackMessages, LoginFeedbackVariant, LoginOutcomeFeedback,
derive_login_feedback_with_messages, login_feedback_from_result_with_messages,
};
use crate::messages::AuthMessage;
use crate::status::AuthDenyReason;
use anyhow::{Error as AuthError, anyhow};
#[derive(Debug)]
struct TestOutcome {
success: bool,
requires_two_factor: bool,
error_code: LoginErrorCode,
message: Option<AuthMessage>,
deny_reason: Option<AuthDenyReason>,
}
impl LoginOutcomeFeedback for TestOutcome {
fn success(&self) -> bool {
self.success
}
fn requires_two_factor(&self) -> bool {
self.requires_two_factor
}
fn error_code(&self) -> LoginErrorCode {
self.error_code
}
fn message(&self) -> Option<&AuthMessage> {
self.message.as_ref()
}
fn deny_reason(&self) -> Option<&AuthDenyReason> {
self.deny_reason.as_ref()
}
}
#[test]
fn derives_message_from_error_code() {
let messages = LoginFeedbackMessages::test_messages();
let outcome = TestOutcome {
success: false,
requires_two_factor: false,
error_code: LoginErrorCode::RateLimited,
message: None,
deny_reason: None,
};
let feedback = derive_login_feedback_with_messages(&messages, &outcome);
assert_eq!(
feedback,
Some((
AuthMessage::from_static("rate_limited"),
LoginFeedbackVariant::Error,
))
);
}
#[test]
fn suppresses_feedback_when_successful() {
let messages = LoginFeedbackMessages::test_messages();
let outcome = TestOutcome {
success: true,
requires_two_factor: false,
error_code: LoginErrorCode::None,
message: Some(AuthMessage::from_static("ignored")),
deny_reason: None,
};
let feedback = derive_login_feedback_with_messages(&messages, &outcome);
assert_eq!(feedback, None);
}
#[test]
fn falls_back_to_outcome_message_when_present() {
let messages = LoginFeedbackMessages::test_messages();
let outcome = TestOutcome {
success: false,
requires_two_factor: false,
error_code: LoginErrorCode::None,
message: Some(AuthMessage::from_static("custom")),
deny_reason: None,
};
let feedback = derive_login_feedback_with_messages(&messages, &outcome);
assert_eq!(
feedback,
Some((
AuthMessage::from_static("custom"),
LoginFeedbackVariant::Error,
))
);
}
#[test]
fn maps_backend_errors_to_error_variant() {
let messages = LoginFeedbackMessages::test_messages();
let result: Result<TestOutcome, AuthError> = Err(anyhow!("oops".to_string()));
let feedback = login_feedback_from_result_with_messages(&messages, &result);
assert_eq!(
feedback,
Some((
AuthMessage::from_static("auth.server_error"),
LoginFeedbackVariant::Error,
))
);
}
}