Struct rocket_auth::Users

pub struct Users { /* fields omitted */ }

The Users struct is used to query users from the database, as well as to create, modify and delete them.

Implementations

impl Users

pub fn open_sqlite(path: impl AsRef<Path>) -> Result<Self, Error>

It creates a Users instance by connecting it to a redis database. If the database does not yet exist it will be created. By default, sessions will be stored on a concurrent HashMap. In order to have persistent sessions see the method open_redis.

let users = Users::open_sqlite("database.db")?;

rocket::ignite()
    .manage(users)
    .launch();

pub fn open_redis(&mut self, path: impl IntoConnectionInfo) -> Result<(), Error>

Opens a redis connection. It allows for sessions to be stored persistently across different launches.

let mut users = Users::open_sqlite("database.db")?;
users.open_redis("redis://127.0.0.1/")?;

rocket::ignite()
    .manage(users)
    .launch();
 

pub fn open_postgres(path: &str) -> Result<Self, Error>

It opens a postgres database connection. I’ve got to admit I haven’t tested this feature yet, so don’t waste your time debugging if it doesn’t work.

let users = Users::open_sqlite("database.db")?;
 
rocket::ignite()
    .manage(users)
    .launch();
 

pub fn get_by_email(&self, email: &str) -> Result<User, Error>

It querys a user by their email.

#[get("/user-information/<email>")]
fn user_information(email: String, users: State<Users>) -> Result<String, Error> {
        
    let user = users.get_by_email(&email)?;
    Ok(format!("{:?}", user))
}

pub fn get_by_id(&self, user_id: i32) -> Result<User, Error>

It querys a user by their email.

 let user = users.get_by_id(3)?;
 format!("{:?}", user)

pub fn create_user(
    &self,
    email: &str,
    password: &str,
    is_admin: bool
) -> Result<(), Error>

Inserts a new user in the database. It will fail if the user already exists.

#![feature(decl_macro)]
#[get("/create_admin/<email>/<password>")]
fn create_admin(email: String, password: String, users: State<Users>) -> Result<String, Error> {
    users.create_user(&email, &password, true)?;
    Ok("User created successfully".into())
}

pub fn delete(&self, id: i32) -> Result<(), Error>

Deletes a user from de database. Note that this method won’t delete the session. To do that use Auth::delete. #[get(“/delete_user/”)] fn delete_user(id: i32, users: State) -> Result { users.delete(id)?; Ok(“The user has been deleted.”) }

pub fn modify(&self, user: &User) -> Result<(), Error>

Modifies a user in the database.

let mut user = users.get_by_id(4)?;
user.set_email("new@email.com");
user.set_password("new password");
users.modify(&user)?;

Trait Implementations

impl<T0: 'static + DBConnection, T1: 'static + SessionManager> From<(T0, T1)> for Users

Additionally, Users can be created from a tuple, where the first element is a database connection, and the second is a redis connection.

let (db_client, connection) = tokio_postgres::connect(postgres_path, NoTls).await?;
let redis_client = redis::Client::open(redis_path)?;
 
let users: Users = (db_client, redis_client).into();

fn from((db, ss): (T0, T1)) -> Users

Performs the conversion.

impl<Conn: 'static + DBConnection> From<Conn> for Users

A Users instance can also be created from a database connection.

let (client, connection) = tokio_postgres::connect("host=localhost user=postgres", NoTls).await?;
let users: Users = client.into();

fn from(db: Conn) -> Users

Performs the conversion.