Struct SessionUser 

pub struct SessionUser {
    pub id: String,
    pub account: String,
    pub label: String,
    pub is_admin: bool,
    pub sequence_number: Option<i64>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

User information stored in the session.

This struct represents authenticated user data that is stored in the session and retrieved during authentication checks. It contains essential user identity and permission information needed for the application.

Fields

id: String

Unique identifier for the user

account: String

User account name or login identifier

label: String

Display name or label for the user

is_admin: bool

Whether the user has administrative privileges

sequence_number: Option<i64>

Database-assigned sequence number (primary key), None for users not yet persisted

created_at: DateTime<Utc>

When the user account was created

updated_at: DateTime<Utc>

When the user account was last updated

Implementations

impl User

pub fn has_admin_privileges(&self) -> bool

Determines if the user has administrative privileges.

A user has admin privileges if:

1. They have the is_admin flag set to true, OR
2. They are the first user in the system (sequence_number = 1)

This method provides consistent admin privilege checking across the codebase and ensures the first user always has admin access regardless of the is_admin flag.

Returns

• true if the user has administrative privileges
• false otherwise

Examples

use oauth2_passkey::SessionUser as User;
use chrono::Utc;

// Regular admin user
let admin_user = User {
    id: "user1".to_string(),
    account: "admin@example.com".to_string(),
    label: "Admin User".to_string(),
    is_admin: true,
    sequence_number: Some(5),
    created_at: Utc::now(),
    updated_at: Utc::now(),
};
assert!(admin_user.has_admin_privileges());

// First user (always admin)
let first_user = User {
    id: "user1".to_string(),
    account: "first@example.com".to_string(),
    label: "First User".to_string(),
    is_admin: false,
    sequence_number: Some(1),
    created_at: Utc::now(),
    updated_at: Utc::now(),
};
assert!(first_user.has_admin_privileges());

// Regular user
let regular_user = User {
    id: "user1".to_string(),
    account: "user@example.com".to_string(),
    label: "Regular User".to_string(),
    is_admin: false,
    sequence_number: Some(2),
    created_at: Utc::now(),
    updated_at: Utc::now(),
};
assert!(!regular_user.has_admin_privileges());

IMPORTANT: This logic must stay in sync with DbUser::has_admin_privileges() and AuthUser::has_admin_privileges() implementations.

Trait Implementations

impl Clone for User

fn clone(&self) -> User

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for User

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for User

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<User> for User

fn from(db_user: DbUser) -> Self

Converts to this type from the input type.

impl From<User> for User

fn from(session_user: User) -> Self

Converts to this type from the input type.

impl Serialize for User

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.