Struct AuthUser 

pub struct AuthUser { /* private fields */ }

The logged-in user. Requests without one are sent to the login route (HTMX requests via HX-Redirect) or get 401 when they want JSON. Use Option<AuthUser> where logging in is optional.

Implementations

impl AuthUser

pub fn token_id(&self) -> Option<i64>

The id of the API token this request logged in with (Authorization: Bearer), or None for a session login. Revoke just that token on “log out” from an app: user.revoke_token(&db, id).

pub fn token_can(&self, ability: &str) -> bool

Whether the API token this request logged in with may do ability (create_token_with(.., &["orders:read"], ..)). Sessions, and tokens made without a list, may do everything.

pub fn has_role(&self, role: &str) -> bool

Whether the user has role (the Permissions module): a global role, or one given in the request’s scope (permissions::set_scope), within its dates.

pub fn has_permission(&self, permission: &str) -> bool

Whether one of the user’s roles grants permission (the Permissions module; the same roles as has_role). allows(permission) also asks App::gate_before.

pub fn has_role_in(&self, role: &str, scope: &Scope) -> bool

Whether the user has role globally or in scope (the record’s, not the request’s), within its dates.

pub fn has_permission_in(&self, permission: &str, scope: &Scope) -> bool

Whether a global role of the user, or one given in scope (the record’s, not the request’s), grants permission now; for policies and handlers that work on one record.

pub fn scopes_with<M: Model>(&self, permission: &str) -> Scopes<M::Key>

The records of model M in which the user holds permission: Scopes::All when a global role grants it, else their keys. See User::scopes_with.

pub fn role_names(&self) -> &[String]

The user’s roles (the Permissions module) in effect: the global ones plus those in the request’s scope, sorted, as they were the first time this was asked.

pub fn can(&self, ability: &str, target: &impl Policy) -> bool

Whether the policy of target allows ability (after App::gate_before).

pub fn authorize(&self, ability: &str, target: &impl Policy) -> Result

Like can, but a refusal becomes a 403 response.

pub fn allows(&self, gate: &str) -> bool

Whether the gate named gate lets this user through: gate_before, then the gate, then the user’s permissions of that name. Unknown names deny.

pub fn gate(&self, gate: &str) -> Result

Like allows, but a refusal becomes a 403 response.

pub async fn allows_async(&self, gate: &str) -> Result<bool>

Whether the gate named gate lets this user through, for gates made with App::gate_async (which may query the database) as well as plain ones. Unknown gates deny.

pub async fn gate_async(&self, gate: &str) -> Result

Like allows_async, but a refusal becomes a 403 response.

pub fn user(&self) -> &User

The logged-in user.

Methods from Deref<Target = User>

pub async fn delete_account(&self, db: &Db) -> Result

Deletes the user (their tokens, notifications and sessions go with the row) and their data grid preferences. The account page’s “delete account” does this.

pub async fn notifications( &self, db: &Db, limit: u32, ) -> Result<Vec<DatabaseNotification>>

The user’s notifications, newest first.

pub async fn notifications_before( &self, db: &Db, before: i64, limit: u32, ) -> Result<Vec<DatabaseNotification>>

The user’s notifications older than the one with id before, newest first: the next page after a list ending at before.

pub async fn notification( &self, db: &Db, id: i64, ) -> Result<Option<DatabaseNotification>>

One of the user’s notifications, or None if it isn’t theirs.

pub async fn unread_notifications( &self, db: &Db, ) -> Result<Vec<DatabaseNotification>>

The user’s unread notifications, newest first.

pub async fn unread_notification_count(&self, db: &Db) -> Result<i64>

How many of the user’s notifications are unread.

pub async fn mark_notification_read(&self, db: &Db, id: i64) -> Result<bool>

Marks one of the user’s notifications read; returns whether it was theirs.

pub async fn mark_notification_unread(&self, db: &Db, id: i64) -> Result<bool>

Marks one of the user’s notifications unread again; returns whether it was theirs.

pub async fn delete_notification(&self, db: &Db, id: i64) -> Result<bool>

Deletes one of the user’s notifications; returns whether it was theirs.

pub async fn delete_notifications(&self, db: &Db) -> Result<u64>

Deletes all the user’s notifications; returns how many there were.

pub async fn mark_all_notifications_read(&self, db: &Db) -> Result<u64>

Marks all the user’s unread notifications read; returns how many there were.

pub async fn assign_role(&self, db: &Db, role: &str) -> Result

Gives the user the existing role role (see permissions::define_role) everywhere and for good.

pub fn assign_role_in<'a>( &self, db: &'a Db, role: &'a str, scope: &Scope, ) -> AssignRole<'a>

Gives the user the existing role role in scope (a store, a team), optionally from / until a date; .await it: user.assign_role_in(&db, "manager", &Scope::of(&store)).until(end).await?. It counts when that scope is the request’s (set_scope) and for User::has_permission_in on that scope. With Scope::global, it is a global role with dates.

pub async fn remove_role(&self, db: &Db, role: &str) -> Result

Takes the global role role away from the user (roles given in a scope stay; see User::remove_role_in).

pub async fn remove_role_in(&self, db: &Db, role: &str, scope: &Scope) -> Result

Takes the role role in scope away from the user.

pub async fn sync_roles(&self, db: &Db, roles: &[&str]) -> Result

Makes the user’s global roles exactly roles (each must exist); roles given in a scope stay.

pub async fn sync_roles_in( &self, db: &Db, roles: &[&str], scope: &Scope, ) -> Result

Makes the user’s roles in scope exactly roles (each must exist), with no dates; other scopes stay.

pub async fn roles(&self, db: &Db) -> Result<Vec<String>>

The names of the user’s roles in effect now, sorted: the global ones plus those in the request’s scope (set_scope), within their dates.

pub async fn permissions(&self, db: &Db) -> Result<Vec<String>>

The permissions the user’s roles in effect now grant, sorted (the same roles as User::roles).

pub async fn assignments(&self, db: &Db) -> Result<Vec<Assignment>>

Every role the user was given, with where and when, ordered by role and scope; ended ones too until permissions:prune deletes them. For account and admin pages.

pub fn has_role_in(&self, role: &str, scope: &Scope) -> bool

Whether this user has role globally or in scope, within its dates, from the roles loaded for the current request (like User::has_role); scope is the record’s, not the request’s.

pub fn has_permission_in(&self, permission: &str, scope: &Scope) -> bool

Whether a global role of this user, or one given in scope, grants permission now: for policies, which check the record’s scope (Scope::of_id::<Store>(order.store_id)) rather than the request’s. Answered from the roles loaded for the current request (like User::has_permission): false for another user and outside a request.

pub fn scopes_with<M: Model>(&self, permission: &str) -> Scopes<M::Key>

The records of model M in which this user holds permission now: Scopes::All when a global role grants it, else the keys of the records whose roles do. For filtering lists (Scopes::apply). Answered from the roles loaded for the current request; nothing for another user and outside a request.

pub async fn create_token( &self, db: &Db, name: &str, expires_at: Option<DateTime>, ) -> Result<NewToken>

Creates an API token that may do everything the user may, optionally expiring at expires_at.

pub async fn create_token_with( &self, db: &Db, name: &str, abilities: &[&str], expires_at: Option<DateTime>, ) -> Result<NewToken>

Creates an API token limited to abilities (checked with AuthUser::token_can or Routes::require_ability), e.g. a read-only token: create_token_with(&db, "reports", &["orders:read"], None). "*" allows everything.

pub async fn tokens(&self, db: &Db) -> Result<Vec<AccessToken>>

The user’s API tokens, newest first.

pub async fn revoke_token(&self, db: &Db, token_id: i64) -> Result<bool>

Revokes one of the user’s tokens; returns whether it existed.

pub async fn revoke_tokens(&self, db: &Db) -> Result<u64>

Revokes all of the user’s tokens.

pub fn get<T: DeserializeOwned>(&self, column: &str) -> Option<T>

One of the app’s own columns (see extra), e.g. user.get::<String>("role"); None if missing, null or of another type. A BOOLEAN column reads as bool on SQLite too, where it is stored as 0 or 1.

pub async fn revoke_sessions(&self, db: &Db) -> Result

Ends every session of the user, e.g. on logout or when an account may be compromised. API tokens stay; see User::revoke_tokens.

pub fn has_password(&self) -> bool

Whether the user has a password. Users made by a social login (auth::register_verified, the renox-oauth crate) don’t: their password is empty, which no typed password matches, until they choose one with “Forgot your password?”.

pub async fn check_password(&self, password: &str) -> bool

Whether password matches the stored hash (Argon2id or an imported bcrypt one).

pub fn can(&self, ability: &str, target: &impl Policy) -> bool

Whether target’s Policy allows this user ability.

pub fn authorize(&self, ability: &str, target: &impl Policy) -> Result

Like User::can, but a refusal becomes a 403 error.

pub fn has_role(&self, role: &str) -> bool

Whether this user has role (the Permissions module), answered from the roles loaded for the current request, so it works in Policy::allows and App::gate_before (“admins may do anything”). It is false for any other user, and outside a request (a job, a command): use the async user.roles(&db) there.

Global roles count, plus those given in the request’s scope (permissions::set_scope), within their dates.

pub fn has_permission(&self, permission: &str) -> bool

Like User::has_role, for a permission granted by one of the user’s roles.

Trait Implementations

impl Clone for AuthUser

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Deref for AuthUser

type Target = User

The resulting type after dereferencing.

fn deref(&self) -> &User

Dereferences the value.

impl From<&AuthUser> for Recipient

fn from(user: &AuthUser) -> Self

Converts to this type from the input type.

impl<S: Send + Sync> FromRequestParts<S> for AuthUser

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

async fn from_request_parts(parts: &mut Parts, _: &S) -> Result<Self, Response>

Perform the extraction.

impl<S: Send + Sync> OptionalFromRequestParts<S> for AuthUser

type Rejection = !

If the extractor fails, it will use this “rejection” type.

async fn from_request_parts( parts: &mut Parts, _: &S, ) -> Result<Option<Self>, Infallible>

Perform the extraction.

impl Viewer for AuthUser

fn as_user(&self) -> &User

The user the policy is asked about.

fn before(&self, ability: &str) -> Option<bool>

App::gate_before’s answer, if any.