state.rs

use crate::app::{AppArgs, AppConfig};
use crate::cookie::SecureCookie;
use actix_web::cookie::Cookie;
use structopt::StructOpt;

#[derive(Clone)]
pub struct AppState {
    pub config: AppConfig,
    pub admin_auth_token: AdminAuthToken,
}

pub struct AppStateBuilder {
    args: Option<AppArgs>,
}

impl AppStateBuilder {
    pub fn new() -> Self {
        AppStateBuilder { args: None }
    }
    pub fn build(&self) -> AppState {
        let config = self.config();
        AppState {
            config: config.clone(),
            admin_auth_token: AdminAuthToken::new(config.admin_cookie_name.to_owned()),
        }
    }

    fn config(&self) -> AppConfig {
        AppConfig::new(self.get_args())
    }

    fn get_args(&self) -> AppArgs {
        match &self.args {
            Some(args) => args.clone(),
            None => AppArgs::from_args(),
        }
    }

    pub fn use_args(&mut self, args: AppArgs) -> &Self {
        self.args = Some(args);
        self
    }
}

impl AppState {
    pub fn builder() -> AppStateBuilder {
        AppStateBuilder::new()
    }
}

#[derive(Clone)]
pub struct AdminAuthToken {
    pub value: Option<String>,
    pub cookie_name: String,
}

impl AdminAuthToken {
    pub fn new(cookie_name: String) -> Self {
        AdminAuthToken {
            value: None,
            cookie_name,
        }
    }

    pub fn match_value(&self, value: String) -> bool {
        match &self.value {
            Some(token) => token.eq(&value),
            None => false,
        }
    }

    pub fn update_value(&mut self) {
        self.value = Some(SecureCookie::generate_token(36))
    }

    pub fn generate_cookie(&mut self) -> Cookie {
        SecureCookie::new(&self.cookie_name, self.value.as_ref().unwrap())
    }
}