Struct Users 

pub struct Users { /* private fields */ }

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

Implementations

impl Users

pub async fn open_sqlite(path: &str) -> Result<Self>

It creates a Users instance by connecting it to a sqlite database. This method uses the sqlx crate. If the database does not yet exist it will return an Error. 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").await?;

rocket::build()
    .manage(users)
    .launch()
    .await.expect("failed launch");

pub async fn create_table(&self) -> Result<(), Error>

Initializes the user table in the database. It won’t drop the table if it already exists. It is necessary to call it explicitly when casting the Users struct from an already established database connection and if the table hasn’t been created yet. If the table already exists then this step is not necessary.

 use sqlx::{sqlite::SqlitePool, Connection};
 use rocket_auth2::{Users, Error};
let mut conn = SqlitePool::connect("./database.db").await?;
let mut users: Users = conn.into();
users.open_redis("redis://127.0.0.1/")?;
users.create_table().await?;

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. Note that persistent sessions also require a secret_key to be set in the Rocket.toml configuration file.

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

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

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

It creates a Users instance by connecting it to a sqlite database. This method uses the rusqlite crate. If the database does not yet exist it will attempt to create it. 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_rusqlite("database.db")?;

rocket::build()
    .manage(users)
    .launch()
    .await.expect("failed launch");

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

It creates a Users instance by connecting it to a postgres database. This method uses the sqlx crate.

let users = Users::open_postgres("postgres://postgres:password@localhost/test").await?;

rocket::build()
    .manage(users)
    .launch().await.expect("failed launch");

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

It creates a Users instance by connecting it to a mysql database. This method uses the sqlx crate.

let users = Users::open_mysql(database_url).await?;

rocket::build()
    .manage(users)
    .launch().await.expect("failed launch");

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

It creates a Users instance by connecting it to a sled database. This method uses the sled crate. If the database does not yet exist it will attempt to create it. 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_sled("database/")?;

rocket::build()
    .manage(users)
    .launch()
    .await;

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

It queries a user by their email.

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

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

It queries a user by their email.

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

pub async fn create_user( &self, email: &str, password: &str, roles: &Roles, ) -> Result<(), Error>

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

#[post("/create_admin/<email>/<password>")]
async fn create_admin(email: String, password: String, users: &State<Users>) -> Result<String, Error> {
users.create_user(&email, &password, &Roles::from_strs(&[ADMIN_ROLE])).await?;
    Ok("User created successfully".into())
}

pub async fn get_all(&self) -> Result<Vec<i32>>

Returns identifiers of all users present in database

#[get("/manage_users")]
async fn create_admin(users: &State<Users>) -> Result<String, Error> {
    for id in users.get_all().await? {
        let user = users.get_by_id(id).await?;
        //...
    }
    Ok("here will be admin panel".to_string())
}

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

Deletes a user from de database. Note that this method won’t delete the session. To do that use Auth::delete.

use rocket::{get, State};
use rocket_auth2::{Users, User, Error};
#[get("/delete_user/<id>")]
async fn delete_user(id: i32, users: &State<Users>) -> Result<String, Error> {
    users.delete(id).await?;
    Ok(String::from("The user has been deleted."))
}

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

Modifies a user in the database.

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

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();
// we create the user table in the
// database if it does not exist.
users.create_table().await?;

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

Converts to this type from the input type.

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

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

use rocket_auth2::{Users, Error};
use tokio_postgres::NoTls;
let (client, connection) = tokio_postgres::connect("host=localhost user=postgres", NoTls).await?;
let users: Users = client.into();
// we create the user table in the
// database if it does not exist.
users.create_table().await?;

fn from(db: Conn) -> Users

Converts to this type from the input type.