Trait mas_storage::user::UserTermsRepository

pub trait UserTermsRepository: Send + Sync {
    type Error;

    // Required method
    fn accept_terms<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 mut self,
        rng: &'life1 mut (dyn RngCore + Send),
        clock: &'life2 dyn Clock,
        user: &'life3 User,
        terms_url: Url,
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
}

A UserTermsRepository helps interacting with the terms of service agreed by a [User]

Required Associated Types

type Error

The error type returned by the repository

Required Methods

fn accept_terms<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, user: &'life3 User, terms_url: Url, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Accept the terms of service by a [User]

Parameters

• rng: A random number generator used to generate IDs
• clock: The clock used to generate timestamps
• user: The [User] accepting the terms
• terms_url: The URL of the terms of service the user is accepting

Errors

Returns Self::Error if the underlying repository fails

Implementations on Foreign Types

impl<R> UserTermsRepository for Box<R>

where R: UserTermsRepository + ?Sized,

type Error = <R as UserTermsRepository>::Error

fn accept_terms<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, rng: &'life1 mut (dyn RngCore + Send), clock: &'life2 dyn Clock, user: &'life3 User, terms_url: Url, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Implementors

impl<R, F, E> UserTermsRepository for MapErr<R, F>

where R: UserTermsRepository, F: FnMut(<R as UserTermsRepository>::Error) -> E + Send + Sync,

type Error = E