Struct GroupManager 

pub struct GroupManager { /* private fields */ }

Available on crate feature auth and non-WebAssembly only.

Group manager

Manages groups and their permissions.

Examples

use reinhardt_auth::group_management::{GroupManager, CreateGroupData};

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

    // Create group
    let group_data = CreateGroupData {
        name: "Editors".to_string(),
        description: Some("Content editors".to_string()),
    };

    let group = manager.create_group(group_data).await.unwrap();
    assert_eq!(group.name, "Editors");

    // Add permissions to group
    manager.add_group_permission(&group.id.to_string(), "blog.add_article").await.unwrap();
    manager.add_group_permission(&group.id.to_string(), "blog.change_article").await.unwrap();

    // Add user to group
    manager.add_user_to_group("alice", &group.id.to_string()).await.unwrap();

    // Check user permissions
    let perms = manager.get_user_permissions("alice").await.unwrap();
    assert!(perms.contains(&"blog.add_article".to_string()));
}

Implementations

impl GroupManager

pub fn new() -> GroupManager

Create a new group manager

Examples

use reinhardt_auth::group_management::GroupManager;

let manager = GroupManager::new();

pub async fn create_group( &mut self, data: CreateGroupData, ) -> Result<Group, GroupManagementError>

Create a new group

Examples

use reinhardt_auth::group_management::{GroupManager, CreateGroupData};

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

    let group_data = CreateGroupData {
        name: "Moderators".to_string(),
        description: Some("Content moderators".to_string()),
    };

    let group = manager.create_group(group_data).await.unwrap();
    assert_eq!(group.name, "Moderators");
}

pub async fn get_group( &self, group_id: &str, ) -> Result<Group, GroupManagementError>

Get group by ID

Examples

use reinhardt_auth::group_management::{GroupManager, CreateGroupData};

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

    let group_data = CreateGroupData {
        name: "Viewers".to_string(),
        description: None,
    };

    let group = manager.create_group(group_data).await.unwrap();
    let retrieved = manager.get_group(&group.id.to_string()).await.unwrap();
    assert_eq!(retrieved.name, "Viewers");
}

pub async fn get_group_by_name( &self, name: &str, ) -> Result<Group, GroupManagementError>

Get group by name

Examples

use reinhardt_auth::group_management::{GroupManager, CreateGroupData};

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

    let group_data = CreateGroupData {
        name: "Contributors".to_string(),
        description: None,
    };

    manager.create_group(group_data).await.unwrap();
    let retrieved = manager.get_group_by_name("Contributors").await.unwrap();
    assert_eq!(retrieved.name, "Contributors");
}

pub async fn delete_group( &mut self, group_id: &str, ) -> Result<(), GroupManagementError>

Delete group

Examples

use reinhardt_auth::group_management::{GroupManager, CreateGroupData};

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

    let group_data = CreateGroupData {
        name: "TempGroup".to_string(),
        description: None,
    };

    let group = manager.create_group(group_data).await.unwrap();
    manager.delete_group(&group.id.to_string()).await.unwrap();
    assert!(manager.get_group(&group.id.to_string()).await.is_err());
}

pub async fn add_group_permission( &mut self, group_id: &str, permission: &str, ) -> Result<(), GroupManagementError>

Add permission to group

Examples

use reinhardt_auth::group_management::{GroupManager, CreateGroupData};

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

    let group_data = CreateGroupData {
        name: "Writers".to_string(),
        description: None,
    };

    let group = manager.create_group(group_data).await.unwrap();
    manager.add_group_permission(&group.id.to_string(), "blog.add_article").await.unwrap();

    let perms = manager.get_group_permissions(&group.id.to_string()).await.unwrap();
    assert!(perms.contains(&"blog.add_article".to_string()));
}

pub async fn remove_group_permission( &mut self, group_id: &str, permission: &str, ) -> Result<(), GroupManagementError>

Remove permission from group

Examples

use reinhardt_auth::group_management::{GroupManager, CreateGroupData};

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

    let group_data = CreateGroupData {
        name: "Reviewers".to_string(),
        description: None,
    };

    let group = manager.create_group(group_data).await.unwrap();
    manager.add_group_permission(&group.id.to_string(), "blog.view_article").await.unwrap();
    manager.remove_group_permission(&group.id.to_string(), "blog.view_article").await.unwrap();

    let perms = manager.get_group_permissions(&group.id.to_string()).await.unwrap();
    assert!(!perms.contains(&"blog.view_article".to_string()));
}

pub async fn get_group_permissions( &self, group_id: &str, ) -> Result<Vec<String>, GroupManagementError>

Get group permissions

Examples

use reinhardt_auth::group_management::{GroupManager, CreateGroupData};

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

    let group_data = CreateGroupData {
        name: "Publishers".to_string(),
        description: None,
    };

    let group = manager.create_group(group_data).await.unwrap();
    manager.add_group_permission(&group.id.to_string(), "blog.add_article").await.unwrap();
    manager.add_group_permission(&group.id.to_string(), "blog.publish_article").await.unwrap();

    let perms = manager.get_group_permissions(&group.id.to_string()).await.unwrap();
    assert_eq!(perms.len(), 2);
}

pub async fn add_user_to_group( &mut self, username: &str, group_id: &str, ) -> Result<(), GroupManagementError>

Add user to group

Examples

use reinhardt_auth::group_management::{GroupManager, CreateGroupData};

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

    let group_data = CreateGroupData {
        name: "Members".to_string(),
        description: None,
    };

    let group = manager.create_group(group_data).await.unwrap();
    manager.add_user_to_group("alice", &group.id.to_string()).await.unwrap();

    let groups = manager.get_user_groups("alice").await.unwrap();
    assert_eq!(groups.len(), 1);
}

pub async fn remove_user_from_group( &mut self, username: &str, group_id: &str, ) -> Result<(), GroupManagementError>

Remove user from group

Examples

use reinhardt_auth::group_management::{GroupManager, CreateGroupData};

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

    let group_data = CreateGroupData {
        name: "Staff".to_string(),
        description: None,
    };

    let group = manager.create_group(group_data).await.unwrap();
    manager.add_user_to_group("bob", &group.id.to_string()).await.unwrap();
    manager.remove_user_from_group("bob", &group.id.to_string()).await.unwrap();

    let groups = manager.get_user_groups("bob").await.unwrap();
    assert_eq!(groups.len(), 0);
}

pub async fn get_user_groups( &self, username: &str, ) -> Result<Vec<Group>, GroupManagementError>

Get user groups

Examples

use reinhardt_auth::group_management::{GroupManager, CreateGroupData};

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

    let group_data1 = CreateGroupData {
        name: "Team1".to_string(),
        description: None,
    };
    let group_data2 = CreateGroupData {
        name: "Team2".to_string(),
        description: None,
    };

    let group1 = manager.create_group(group_data1).await.unwrap();
    let group2 = manager.create_group(group_data2).await.unwrap();

    manager.add_user_to_group("charlie", &group1.id.to_string()).await.unwrap();
    manager.add_user_to_group("charlie", &group2.id.to_string()).await.unwrap();

    let groups = manager.get_user_groups("charlie").await.unwrap();
    assert_eq!(groups.len(), 2);
}

pub async fn get_user_permissions( &self, username: &str, ) -> Result<Vec<String>, GroupManagementError>

Get user permissions from all groups

Examples

use reinhardt_auth::group_management::{GroupManager, CreateGroupData};

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

    let group_data = CreateGroupData {
        name: "Developers".to_string(),
        description: None,
    };

    let group = manager.create_group(group_data).await.unwrap();
    manager.add_group_permission(&group.id.to_string(), "code.commit").await.unwrap();
    manager.add_group_permission(&group.id.to_string(), "code.review").await.unwrap();
    manager.add_user_to_group("diana", &group.id.to_string()).await.unwrap();

    let perms = manager.get_user_permissions("diana").await.unwrap();
    assert!(perms.contains(&"code.commit".to_string()));
    assert!(perms.contains(&"code.review".to_string()));
}

pub async fn list_groups(&self) -> Vec<Group>

List all groups

Examples

use reinhardt_auth::group_management::{GroupManager, CreateGroupData};

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

    let group_data1 = CreateGroupData {
        name: "Group1".to_string(),
        description: None,
    };
    let group_data2 = CreateGroupData {
        name: "Group2".to_string(),
        description: None,
    };

    manager.create_group(group_data1).await.unwrap();
    manager.create_group(group_data2).await.unwrap();

    let groups = manager.list_groups().await;
    assert_eq!(groups.len(), 2);
}

pub fn get_permissions_for_groups_sync( &self, group_names: &[String], ) -> HashSet<String>

Synchronously resolve permissions for the given group names.

Uses try_read() for non-blocking access to internal state. Returns an empty set if the lock is held by a writer.

This method is designed for use in synchronous contexts such as PermissionsMixin::get_group_permissions().

Trait Implementations

impl Debug for GroupManager

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

Formats the value using the given formatter.

impl Default for GroupManager

fn default() -> GroupManager

Returns the “default value” for a type.