Trait mas_storage::user::UserRepository

source · 
pub trait UserRepository: Send + Sync {
    type Error;

    // Required methods
    fn lookup<'life0, 'async_trait>(
        &'life0 mut self,
        id: Ulid,
    ) -> Pin<Box<dyn Future<Output = Result<Option<User>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn find_by_username<'life0, 'life1, 'async_trait>(
        &'life0 mut self,
        username: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<User>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn add<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 mut self,
        rng: &'life1 mut (dyn RngCore + Send),
        clock: &'life2 dyn Clock,
        username: String,
    ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn exists<'life0, 'life1, 'async_trait>(
        &'life0 mut self,
        username: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn lock<'life0, 'life1, 'async_trait>(
        &'life0 mut self,
        clock: &'life1 dyn Clock,
        user: User,
    ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn unlock<'life0, 'async_trait>(
        &'life0 mut self,
        user: User,
    ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn set_can_request_admin<'life0, 'async_trait>(
        &'life0 mut self,
        user: User,
        can_request_admin: bool,
    ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list<'life0, 'life1, 'async_trait>(
        &'life0 mut self,
        filter: UserFilter<'life1>,
        pagination: Pagination,
    ) -> Pin<Box<dyn Future<Output = Result<Page<User>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn count<'life0, 'life1, 'async_trait>(
        &'life0 mut self,
        filter: UserFilter<'life1>,
    ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn acquire_lock_for_sync<'life0, 'life1, 'async_trait>(
        &'life0 mut self,
        user: &'life1 User,
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
}
Expand description

A UserRepository helps interacting with [User] saved in the storage backend

Required Associated Types§

source

type Error

The error type returned by the repository

Required Methods§

source

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<User>, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Lookup a [User] by its ID

Returns None if no [User] was found

§Parameters
  • id: The ID of the [User] to lookup
§Errors

Returns Self::Error if the underlying repository fails

source

fn find_by_username<'life0, 'life1, 'async_trait>( &'life0 mut self, username: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<User>, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find a [User] by its username

Returns None if no [User] was found

§Parameters
  • username: The username of the [User] to lookup
§Errors

Returns Self::Error if the underlying repository fails

source

fn add<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, username: String, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a new [User]

Returns the newly created [User]

§Parameters
  • rng: A random number generator to generate the [User] ID
  • clock: The clock used to generate timestamps
  • username: The username of the [User]
§Errors

Returns Self::Error if the underlying repository fails

source

fn exists<'life0, 'life1, 'async_trait>( &'life0 mut self, username: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check if a [User] exists

Returns true if the [User] exists, false otherwise

§Parameters
  • username: The username of the [User] to lookup
§Errors

Returns Self::Error if the underlying repository fails

source

fn lock<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, user: User, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Lock a [User]

Returns the locked [User]

§Parameters
  • clock: The clock used to generate timestamps
  • user: The [User] to lock
§Errors

Returns Self::Error if the underlying repository fails

source

fn unlock<'life0, 'async_trait>( &'life0 mut self, user: User, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Unlock a [User]

Returns the unlocked [User]

§Parameters
  • user: The [User] to unlock
§Errors

Returns Self::Error if the underlying repository fails

source

fn set_can_request_admin<'life0, 'async_trait>( &'life0 mut self, user: User, can_request_admin: bool, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Set whether a [User] can request admin

Returns the [User] with the new can_request_admin value

§Parameters
  • user: The [User] to update
§Errors

Returns Self::Error if the underlying repository fails

source

fn list<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UserFilter<'life1>, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<User>, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List [User] with the given filter and pagination

§Parameters
  • filter: The filter parameters
  • pagination: The pagination parameters
§Errors

Returns Self::Error if the underlying repository fails

source

fn count<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UserFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count the [User] with the given filter

§Parameters
  • filter: The filter parameters
§Errors

Returns Self::Error if the underlying repository fails

source

fn acquire_lock_for_sync<'life0, 'life1, 'async_trait>( &'life0 mut self, user: &'life1 User, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Acquire a lock on the user to make sure device operations are done in a sequential way. The lock is released when the repository is saved or rolled back.

§Parameters
  • user: The user to lock
§Errors

Returns Self::Error if the underlying repository fails

Implementations on Foreign Types§

source§

impl<R> UserRepository for Box<R>
where R: UserRepository + ?Sized,

§

type Error = <R as UserRepository>::Error

source§

fn lookup<'life0, 'async_trait>( &'life0 mut self, id: Ulid, ) -> Pin<Box<dyn Future<Output = Result<Option<User>, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

source§

fn find_by_username<'life0, 'life1, 'async_trait>( &'life0 mut self, username: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<User>, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

source§

fn add<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, username: String, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

source§

fn exists<'life0, 'life1, 'async_trait>( &'life0 mut self, username: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

source§

fn lock<'life0, 'life1, 'async_trait>( &'life0 mut self, clock: &'life1 dyn Clock, user: User, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

source§

fn unlock<'life0, 'async_trait>( &'life0 mut self, user: User, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

source§

fn set_can_request_admin<'life0, 'async_trait>( &'life0 mut self, user: User, can_request_admin: bool, ) -> Pin<Box<dyn Future<Output = Result<User, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

source§

fn list<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UserFilter<'life1>, pagination: Pagination, ) -> Pin<Box<dyn Future<Output = Result<Page<User>, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

source§

fn count<'life0, 'life1, 'async_trait>( &'life0 mut self, filter: UserFilter<'life1>, ) -> Pin<Box<dyn Future<Output = Result<usize, Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

source§

fn acquire_lock_for_sync<'life0, 'life1, 'async_trait>( &'life0 mut self, user: &'life1 User, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Implementors§

source§

impl<R, F, E> UserRepository for MapErr<R, F>
where R: UserRepository, F: FnMut(<R as UserRepository>::Error) -> E + Send + Sync,

§

type Error = E