ldap_backend/src/lib.rs

pub mod methods;
use dotenv::dotenv;
use ldap3::{LdapConn, Scope, SearchEntry};
use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
use sqlx::{Error, Pool, Sqlite};
use std::env;
use std::str::FromStr;
use std::time::{SystemTime, UNIX_EPOCH};
use tide::prelude::*;

#[derive(Debug, Deserialize, Serialize, sqlx::FromRow)]
pub struct AccountsPending {
    user: String,
    mail: String,
    cn: String,
    sn: String,
    auth_code: String,

    // action will be what to do with it
    action: String,
    // will only last for a few hours
    expiry: i64,
}

#[derive(Debug, Deserialize, Serialize, sqlx::FromRow)]
pub struct Accounts {
    user: String,
    uid: i64,
    discord: Option<String>,
    mail: String,
    student_id: String,
    enabled: bool,
    secure: bool, 
}

pub async fn db_init(config: &Config) -> Result<Pool<Sqlite>, Error> {
    let database = format!("{}/{}", &config.home, &config.database);
    let pool = SqlitePoolOptions::new()
        .max_connections(5)
        .connect_with(SqliteConnectOptions::from_str(&format!("sqlite://{}", database))?.create_if_missing(true))
        .await?;

    sqlx::query(
        "CREATE TABLE IF NOT EXISTS accounts_pending (
            user text primary key,
            mail text not null,
            cn text not null,
            sn text not null,
            action text not null,
            auth_code text not null,
            expiry integer not null
         )",
    )
    .execute(&pool)
    .await?;

    // this is for active use
    sqlx::query(
        "CREATE TABLE IF NOT EXISTS accounts (
            user text primary key,
            uid integer not null,
            discord text,
            mail text not null,
            student_id text not null,
            enabled integer not null,
            secure integer not null
         )",
    )
    .execute(&pool)
    .await?;

    sqlx::query("CREATE INDEX IF NOT EXISTS index_uid_number ON accounts (uid)")
        .execute(&pool)
        .await?;

    update_accounts(&pool, config).await;

    Ok(pool)
}

pub fn get_now() -> i64 {
    if let Ok(x) = SystemTime::now().duration_since(UNIX_EPOCH) {
        x.as_secs() as i64
    } else {
        0
    }
}

#[derive(Clone)]
pub struct State {
    pub db: Pool<Sqlite>,
    pub config: Config,
}

#[derive(Debug, Clone)]
pub struct Config {
    pub ldap_host: String,
    pub ldap_admin: String,
    pub ldap_admin_pw: String,
    pub home: String,
    pub database: String,
    pub csv: String,
    pub host_port: String,
}

pub fn get_config() -> Config {
    dotenv().ok();

    // reasonable defaults
    let mut config = Config {
        ldap_host: "".to_string(),
        ldap_admin: "".to_string(),
        ldap_admin_pw: "".to_string(),
        home: ".".to_string(),
        database: "database.db".to_string(),
        csv: "wolves.csv".to_string(),
        host_port: "127.0.0.1:8087".to_string(),
    };

    if let Ok(x) = env::var("LDAP_HOST") {
        config.ldap_host = x.trim().to_string();
    }
    if let Ok(x) = env::var("LDAP_ADMIN") {
        config.ldap_admin = x.trim().to_string();
    }
    if let Ok(x) = env::var("LDAP_ADMIN_PW") {
        config.ldap_admin_pw = x.trim().to_string();
    }
    if let Ok(x) = env::var("HOME") {
        config.home = x.trim().to_string();
    }
    if let Ok(x) = env::var("DATABASE") {
        config.database = x.trim().to_string();
    }
    if let Ok(x) = env::var("CSV") {
        config.csv = x.trim().to_string();
    }
    if let Ok(x) = env::var("HOST_PORT") {
        config.host_port = x.trim().to_string();
    }

    config
}

async fn update_accounts(pool: &Pool<Sqlite>, config: &Config) {
    let mut ldap = LdapConn::new(&config.ldap_host).unwrap();

    ldap.simple_bind(&config.ldap_admin, &config.ldap_admin_pw).unwrap().success().unwrap();

    // use this to pre load a large chunk of data
    if let Ok(x) = ldap.search(
        "ou=users,dc=skynet,dc=ie", 
        Scope::OneLevel, 
        "(objectClass=*)", 
        vec!["uid", "uidNumber", "skDiscord", "skMemberOf", "mail", "skID", "skSecure"]
    ) {
        if let Ok((rs, _res)) = x.success() {
            for entry in rs {
                let tmp = SearchEntry::construct(entry);

                let mut tmp_account = Accounts {
                    user: "".to_string(),
                    uid: 0,
                    discord: None,
                    mail: "".to_string(),
                    student_id: "".to_string(),
                    enabled: false,
                    secure: false,
                };

                // pull out the required info
                if tmp.attrs.contains_key("uid") && !tmp.attrs["uid"].is_empty() {
                    tmp_account.user = tmp.attrs["uid"][0].clone();
                }
                if tmp.attrs.contains_key("uidNumber") && !tmp.attrs["uidNumber"].is_empty() {
                    tmp_account.uid = tmp.attrs["uidNumber"][0].clone().parse().unwrap_or(0);
                }
                if tmp.attrs.contains_key("skDiscord") && !tmp.attrs["skDiscord"].is_empty() {
                    tmp_account.discord = Option::from(tmp.attrs["skDiscord"][0].clone());
                }
                if tmp.attrs.contains_key("mail") && !tmp.attrs["mail"].is_empty() {
                    tmp_account.mail = tmp.attrs["mail"][0].clone();
                }
                if tmp.attrs.contains_key("skID") && !tmp.attrs["skID"].is_empty() {
                    tmp_account.student_id = tmp.attrs["skID"][0].clone();
                }
                if tmp.attrs.contains_key("skMemberOf") 
                  && !tmp.attrs["skMemberOf"].is_empty() 
                  && tmp.attrs["skMemberOf"].contains(&String::from("cn=skynet-users-linux,ou=groups,dc=skynet,dc=ie")) 
                {
                    tmp_account.enabled = true;
                }
                if tmp.attrs.contains_key("skSecure") && !tmp.attrs["skSecure"].is_empty() {
                    tmp_account.secure = true;
                }

                if !tmp_account.user.is_empty() {
                    sqlx::query_as::<_, Accounts>(
                        "
                        INSERT OR REPLACE INTO accounts (user, uid, discord, mail, student_id, enabled, secure)
                        VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
                        ",
                    )
                    .bind(&tmp_account.user)
                    .bind(tmp_account.uid)
                    .bind(&tmp_account.discord)
                    .bind(&tmp_account.mail)
                    .bind(&tmp_account.student_id)
                    .bind(tmp_account.enabled)
                    .bind(tmp_account.secure)
                    .fetch_optional(pool)
                    .await
                    .ok();
                }
            }
        }
    }

    // done with ldap
    ldap.unbind().unwrap();
}