Struct UserManager 

pub struct UserManager<H>
where
    H: PasswordHasher,
{ /* private fields */ }

Available on crate feature auth and non-WebAssembly only.

User manager

Provides CRUD operations for users.

Examples

use reinhardt_auth::user_management::{UserManager, CreateUserData};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let hasher = MockHasher;
    let mut manager = UserManager::new(hasher);

    // Create user
    let user_data = CreateUserData {
        username: "alice".to_string(),
        email: "alice@example.com".to_string(),
        password: "password123".to_string(),
        is_active: true,
        is_admin: false,
    };

    let user = manager.create_user(user_data).await.unwrap();
    assert_eq!(user.username, "alice");

    // Get user
    let retrieved = manager.get_user(&user.id.to_string()).await.unwrap();
    assert_eq!(retrieved.username, "alice");

    // Delete user
    manager.delete_user(&user.id.to_string()).await.unwrap();
    assert!(manager.get_user(&user.id.to_string()).await.is_err());
    Ok(())
}

Implementations

impl<H> UserManager<H>

where H: PasswordHasher,

pub fn new(hasher: H) -> UserManager<H>

Create a new user manager

Examples

use reinhardt_auth::user_management::UserManager;

let manager = UserManager::new(MockHasher);

pub async fn create_user( &mut self, data: CreateUserData, ) -> Result<SimpleUser, UserManagementError>

Create a new user

Examples

use reinhardt_auth::user_management::{UserManager, CreateUserData};

#[tokio::main]
async fn main() {
    let mut manager = UserManager::new(MockHasher);

    let user_data = CreateUserData {
        username: "bob".to_string(),
        email: "bob@example.com".to_string(),
        password: "securepass".to_string(),
        is_active: true,
        is_admin: false,
    };

    let user = manager.create_user(user_data).await.unwrap();
    assert_eq!(user.username, "bob");
}

pub async fn get_user( &self, user_id: &str, ) -> Result<SimpleUser, UserManagementError>

Get user by ID

Examples

use reinhardt_auth::user_management::{UserManager, CreateUserData};

#[tokio::main]
async fn main() {
    let mut manager = UserManager::new(MockHasher);

    let user_data = CreateUserData {
        username: "charlie".to_string(),
        email: "charlie@example.com".to_string(),
        password: "password123".to_string(),
        is_active: true,
        is_admin: false,
    };

    let user = manager.create_user(user_data).await.unwrap();
    let retrieved = manager.get_user(&user.id.to_string()).await.unwrap();
    assert_eq!(retrieved.username, "charlie");
}

pub async fn get_user_by_username( &self, username: &str, ) -> Result<SimpleUser, UserManagementError>

Get user by username

Examples

use reinhardt_auth::user_management::{UserManager, CreateUserData};

#[tokio::main]
async fn main() {
    let mut manager = UserManager::new(MockHasher);

    let user_data = CreateUserData {
        username: "diana".to_string(),
        email: "diana@example.com".to_string(),
        password: "password123".to_string(),
        is_active: true,
        is_admin: false,
    };

    manager.create_user(user_data).await.unwrap();
    let retrieved = manager.get_user_by_username("diana").await.unwrap();
    assert_eq!(retrieved.username, "diana");
}

pub async fn update_user( &mut self, user_id: &str, data: UpdateUserData, ) -> Result<SimpleUser, UserManagementError>

Update user

Examples

use reinhardt_auth::user_management::{UserManager, CreateUserData, UpdateUserData};

#[tokio::main]
async fn main() {
    let mut manager = UserManager::new(MockHasher);

    let user_data = CreateUserData {
        username: "eve".to_string(),
        email: "eve@example.com".to_string(),
        password: "password123".to_string(),
        is_active: true,
        is_admin: false,
    };

    let user = manager.create_user(user_data).await.unwrap();

    let update_data = UpdateUserData {
        email: Some("newemail@example.com".to_string()),
        is_active: Some(false),
        is_admin: None,
    };

    let updated = manager.update_user(&user.id.to_string(), update_data).await.unwrap();
    assert_eq!(updated.email, "newemail@example.com");
    assert!(!updated.is_active);
}

pub async fn delete_user( &mut self, user_id: &str, ) -> Result<(), UserManagementError>

Delete user

Examples

use reinhardt_auth::user_management::{UserManager, CreateUserData};

#[tokio::main]
async fn main() {
    let mut manager = UserManager::new(MockHasher);

    let user_data = CreateUserData {
        username: "frank".to_string(),
        email: "frank@example.com".to_string(),
        password: "password123".to_string(),
        is_active: true,
        is_admin: false,
    };

    let user = manager.create_user(user_data).await.unwrap();
    manager.delete_user(&user.id.to_string()).await.unwrap();
    assert!(manager.get_user(&user.id.to_string()).await.is_err());
}

pub async fn list_users(&self) -> Vec<SimpleUser>

List all users

Examples

use reinhardt_auth::user_management::{UserManager, CreateUserData};

#[tokio::main]
async fn main() {
    let mut manager = UserManager::new(MockHasher);

    let user_data1 = CreateUserData {
        username: "grace".to_string(),
        email: "grace@example.com".to_string(),
        password: "password123".to_string(),
        is_active: true,
        is_admin: false,
    };

    let user_data2 = CreateUserData {
        username: "henry".to_string(),
        email: "henry@example.com".to_string(),
        password: "password123".to_string(),
        is_active: true,
        is_admin: false,
    };

    manager.create_user(user_data1).await.unwrap();
    manager.create_user(user_data2).await.unwrap();

    let users = manager.list_users().await;
    assert_eq!(users.len(), 2);
}

pub async fn verify_password( &self, user_id: &str, password: &str, ) -> Result<bool, UserManagementError>

Verify user password

Examples

use reinhardt_auth::user_management::{UserManager, CreateUserData};

#[tokio::main]
async fn main() {
    let mut manager = UserManager::new(MockHasher);

    let user_data = CreateUserData {
        username: "iris".to_string(),
        email: "iris@example.com".to_string(),
        password: "mypassword".to_string(),
        is_active: true,
        is_admin: false,
    };

    let user = manager.create_user(user_data).await.unwrap();
    assert!(manager.verify_password(&user.id.to_string(), "mypassword").await.unwrap());
    assert!(!manager.verify_password(&user.id.to_string(), "wrongpassword").await.unwrap());
}