eve-esi-api 0.0.4

mod api;
pub mod domain;
mod errors;

use api::authent::builder::Oauth2AuthentBuilder;
pub use api::authent::oauth2::{Authent, Verify};
pub(crate) type Result<T> = std::result::Result<T, EveEsiError>;

pub use api::client::ApiClient;

pub use api::characters;
pub use api::market;
pub use api::search;
pub use api::universe;
pub use api::wallet;
pub use domain::typedef::*;
pub use errors::EveEsiError;

/// The main struct you will use.
///
/// Eve_api struct is backed internally by ARCs, you can use it in async, and clone it with little overhead.
///
/// ```rust,no_run
/// async {
///     let client_id = std::env::var("CLIENT_ID").expect("CLIENT_ID needed as environment variable");
///     let client_secret = std::env::var("CLIENT_SECRET").expect("CLIENT_SECRET missing");
///     let scopes = vec!["publicData"];
///     let params = EveApiParam {
///         client_id,
///         client_secret,
///         scopes,
///         token_path: None,
///     };
///     let eve_api = eve_esi_api::EveApi::new(params).await?;
///     println!("logged as {}", eve_api.character().character_name);
///     let regions = eve_esi_api::universe::all_regions(eve_api.client()).await?;
/// }
/// ```
///
/// Api calls take a reference to a client.
/// They are grouped by eve-esi groups structure :
/// universe, wallet, market are currently implemented
///
#[derive(Clone)]
pub struct EveApi {
    client: ApiClient,
    character: Verify,
}

pub struct EveApiParam {
    client_id: String,
    client_secret: String,
    scopes: Vec<String>,
    token_path: Option<String>,
    esi_url: String,
    auth_url: String,
    user_agent: String,
}

impl EveApi {
    pub async fn new(params: EveApiParam) -> Result<Self> {
        let mut auth_builder = Oauth2AuthentBuilder::new(params.client_id, params.client_secret)
            .with_scopes(params.scopes.iter().map(|s| s.as_str()).collect());
        if let Some(token) = params.token_path {
            auth_builder = auth_builder.with_token_path(&token);
        }

        let mut auth = auth_builder.build();

        auth.authenticate().await?;
        let character = auth.verify().await?;
        let client = ApiClient::new(
            auth.get_authent()?,
            params.esi_url,
            params.auth_url,
            params.user_agent,
        )?;

        Ok(EveApi { client, character })
    }

    /// client to give in api calls
    pub fn client(&self) -> &ApiClient {
        &self.client
    }

    /// logged character
    pub fn character(&self) -> &Verify {
        &self.character
    }
}

impl EveApiParam {
    pub fn new(client_id: String, client_secret: String) -> Self {
        Self {
            client_id,
            client_secret,
            scopes: vec![],
            token_path: None,
            auth_url: "https://login.eveonline.com".to_string(),
            esi_url: "https://esi.evetech.net/latest".to_string(),
            user_agent: "eve_esi_api_0.0.3".to_string(),
        }
    }

    pub fn with_token_path(self, token_path: String) -> Self {
        Self {
            client_id: self.client_id,
            client_secret: self.client_secret,
            scopes: self.scopes,
            token_path: Some(token_path),
            auth_url: self.auth_url,
            esi_url: self.esi_url,
            user_agent: self.user_agent,
        }
    }

    pub fn with_scopes<S>(self, scopes: Vec<S>) -> Self
    where
        S: Into<String>,
    {
        Self {
            client_id: self.client_id,
            client_secret: self.client_secret,
            scopes: scopes
                .into_iter()
                .map(|s| <S as Into<String>>::into(s))
                .collect(),
            token_path: self.token_path,
            auth_url: self.auth_url,
            esi_url: self.esi_url,
            user_agent: self.user_agent,
        }
    }

    pub fn add_scope<S>(self, scope: S) -> Self
    where
        S: Into<String>,
    {
        let mut scopes = self.scopes;
        scopes.push(scope.into());
        Self {
            client_id: self.client_id,
            client_secret: self.client_secret,
            scopes,
            token_path: self.token_path,
            auth_url: self.auth_url,
            esi_url: self.esi_url,
            user_agent: self.user_agent,
        }
    }

    pub fn with_esi_url(self, esi_url: String) -> Self {
        Self {
            client_id: self.client_id,
            client_secret: self.client_secret,
            scopes: self.scopes,
            token_path: self.token_path,
            auth_url: self.auth_url,
            esi_url,
            user_agent: self.user_agent,
        }
    }

    pub fn with_auth_url(self, auth_url: String) -> Self {
        Self {
            client_id: self.client_id,
            client_secret: self.client_secret,
            scopes: self.scopes,
            token_path: self.token_path,
            auth_url,
            esi_url: self.esi_url,
            user_agent: self.user_agent,
        }
    }

    pub fn with_user_agent(self, user_agent: String) -> Self {
        Self {
            client_id: self.client_id,
            client_secret: self.client_secret,
            scopes: self.scopes,
            token_path: self.token_path,
            auth_url: self.auth_url,
            esi_url: self.esi_url,
            user_agent,
        }
    }
}