valorant_api/

lib.rs

#![deny(warnings)]
#![deny(unused)]
#![deny(clippy::expect_used)]
#![deny(clippy::get_unwrap)]
#![deny(clippy::exit)]
#![deny(clippy::indexing_slicing)]
#![deny(clippy::panic)]
#![deny(clippy::panic_in_result_fn)]
#![deny(clippy::unreachable)]
#![deny(clippy::unwrap_used)]
#![deny(clippy::unwrap_in_result)]
#![deny(clippy::print_stdout)]
#![allow(clippy::upper_case_acronyms)]

//! # Valorant API
//! This crate is a wrapper for the In-Game Valorant API.
//!
//! ## Usage
//!
//! ### 1. Authenticate
//!
//! To use this crate, you need to authenticate with your Riot Games account.
//! Currently, the only way to do this is by using a username and password (no 2FA).
//!
//! ```rust no_run
//! use valorant_api::utils::credentials_manager::CredentialsManager;
//! use valorant_api::utils::network::http_client::SimpleHttpClient;
//!
//! #[tokio::main]
//! async fn main() {
//!     let http_client = SimpleHttpClient::new();
//!     let mut credentials_manager = valorant_api::utils::credentials_manager::CredentialsManager::new();
//!     let result = credentials_manager
//!         .authenticate(&http_client, "username", "password")
//!         .await;
//!     match result {
//!         Ok(_) => println!("Authenticated"),
//!         Err(_) => println!("Error while authenticating"),
//!     }
//! }
//! ```
//!
//! ### 2. Use the API
//!
//! ```rust no_run
//! use valorant_api::enums::region::Region;
//! use uuid::Uuid;
//! use std::collections::HashMap;
//!
//! let puuid = Uuid::parse_str("ee89b4d9-13d0-5832-8dd7-eb5d8806d918").expect("Invalid UUID");
//! let region = Region::EU;
//! let queries = HashMap::new();
//! let result = valorant_api::get_competitve_updates_v1(credentials_manager, &http_client, region, &puuid, queries).await;
//! println!("Result: {:#?}", result);
//! ```
//!
//! ## Endpoints
//!
//! ### Competitive Updates V1
//!
//! Function: [`get_competitive_updates_v1`]
//!
//! Result Type: [`CompetitiveUpdatesV1`]
//!
//! ### Match Details V1
//!
//! Function: [`get_match_details_v1`]
//!
//! Result Type: [`MatchDetailsV1`]
//!
//! ### Match History V1
//!
//! Function: [`get_match_history_v1`]
//!
//! Result Type: [`MatchHistoryV1`]
//!
//! ### MMRV1
//!
//! Function: [`get_mmr_details_v1`]
//!
//! Result Type: [`MMRDetailsV1`]
//!
//! ### Leaderboard V1
//!
//! Function: [`get_leaderboard_v1`]
//!
//! Result Type: [`LeaderboardV1`]
//!
//! ### Content V3
//!
//! Function: [`get_content_v3`]
//!
//! Result Type: [`ContentV3`]
//!
//! ### Store Offers V1
//!
//! Function: [`get_store_offers_v1`]
//!
//! Result Type: [`StoreOffersV1`]
//!
//! ### Store Front V2
//!
//! Function: [`get_store_front_v2`]
//!
//! Result Type: [`StoreFrontV2`]
//!

use std::collections::HashMap;
use std::str::FromStr;
use std::string::ToString;

use reqwest::{Client, Method};
use url::Url;
use uuid::Uuid;

use crate::enums::esport_locales::EsportsLocales;
use crate::enums::platform::Platform;
use crate::enums::query_arg::{
    CompetitiveUpdateQueryArg, LeaderboardQueryArg, MatchHistoryQueryArg,
};
use crate::enums::region::Region;
use crate::errors::response_error::RequestError;
use crate::response_types::account_aliases_v1::AccountAliasesV1;
use crate::response_types::competitive_updates_v1::CompetitiveUpdatesV1;
use crate::response_types::content_v3::ContentV3;
use crate::response_types::esports_service_leagues::EsportsLeagues;
use crate::response_types::esports_service_schedule::EsportsSchedule;
use crate::response_types::esports_service_vods::EsportsVod;
use crate::response_types::leaderboard_v1::LeaderboardV1;
use crate::response_types::matchdetails_v1::MatchDetailsV1;
use crate::response_types::matchhistory_v1::MatchHistoryV1;
use crate::response_types::mmrdetails_v1::MMRDetailsV1;
use crate::response_types::store_front_v2::StoreFrontV2;
use crate::response_types::store_offers_v1::StoreOffersV1;
use crate::utils::credentials_manager::CredentialsManager;
use crate::utils::fetch::fetch_endpoint;
use crate::utils::functions::set_query_args;

pub mod enums;
pub mod errors;
pub mod response_types;
pub mod utils;

const ESPORTS_API_KEY: &str = "0TvQnueqKa5mxJntVWt0w4LpLfEkrV1Ta8rQBb9Z";

pub async fn get_match_history_v1(
    credentials_manager: &CredentialsManager,
    http_client: &Client,
    region: Region,
    puuid: &Uuid,
    query_args: HashMap<MatchHistoryQueryArg, String>,
) -> Result<MatchHistoryV1, RequestError> {
    //! Get the match history of a player
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the player
    //! * `puuid` - The puuid of the player
    //! * `query_args` - The query arguments
    //! # Example
    //! ```rust no_run
    //! let puuid = Uuid::parse_str("ee89b4d9-13d0-5832-8dd7-eb5d8806d918").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let queries = HashMap::new();
    //! let result = valorant_api::get_match_history_v1(credentials_manager, &http_client, region, &puuid, queries).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let mut url = Url::from_str(&format!(
        "https://pd.{}.a.pvp.net/match-history/v1/history/{}",
        region.to_shard(),
        puuid
    ))?;
    set_query_args(&mut url, query_args.into_iter());

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_match_details_v1(
    credentials_manager: &CredentialsManager,
    http_client: &Client,
    region: Region,
    match_id: &Uuid,
) -> Result<MatchDetailsV1, RequestError> {
    //! Get the match details of a match
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the match
    //! * `match_id` - The match id of the match
    //! # Example
    //! ```rust no_run
    //! let match_id = Uuid::parse_str("3100c02b-17d2-4adb-97b5-e45dee67d292").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let result = valorant_api::get_match_details_v1(credentials_manager, &http_client, region, &match_id).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let url = Url::from_str(&format!(
        "https://pd.{}.a.pvp.net/match-details/v1/matches/{}",
        region.to_shard(),
        match_id
    ))?;

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_mmr_details_v1(
    credentials_manager: &CredentialsManager,
    http_client: &Client,
    region: Region,
    puuid: &Uuid,
) -> Result<MMRDetailsV1, RequestError> {
    //! Get the mmr of a player
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the player
    //! * `puuid` - The puuid of the player
    //! # Example
    //! ```rust no_run
    //! let puuid = Uuid::parse_str("ee89b4d9-13d0-5832-8dd7-eb5d8806d918").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let result = valorant_api::get_mmr_details_v1(credentials_manager, &http_client, region, &puuid).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let url = Url::from_str(&format!(
        "https://pd.{}.a.pvp.net/mmr/v1/players/{}",
        region.to_shard(),
        puuid
    ))?;

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_competitive_updates_v1(
    credentials_manager: &CredentialsManager,
    http_client: &Client,
    region: Region,
    puuid: &Uuid,
    query_args: HashMap<CompetitiveUpdateQueryArg, String>,
) -> Result<CompetitiveUpdatesV1, RequestError> {
    //! Get the competitve updates of a player
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the player
    //! * `puuid` - The puuid of the player
    //! * `query_args` - The query arguments
    //! # Example
    //! ```rust no_run
    //! let puuid = Uuid::parse_str("ee89b4d9-13d0-5832-8dd7-eb5d8806d918").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let queries = HashMap::new();
    //! let result = valorant_api::get_competitve_updates_v1(credentials_manager, &http_client, region, &puuid, queries).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let mut url = Url::from_str(&format!(
        "https://pd.{}.a.pvp.net/mmr/v1/players/{}/competitiveupdates",
        region.to_shard(),
        puuid
    ))?;
    set_query_args(&mut url, query_args.into_iter());

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_content_v3(
    credentials_manager: &CredentialsManager,
    http_client: &Client,
    region: Region,
) -> Result<ContentV3, RequestError> {
    //! Get the content of the game
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the player
    //! # Example
    //! ```rust no_run
    //! let region = Region::EU;
    //! let result = valorant_api::get_content_v1(credentials_manager, &http_client, region).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let url = Url::from_str(&format!(
        "https://shared.{}.a.pvp.net/content-service/v3/content",
        region.to_shard(),
    ))?;

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_leaderboard_v1(
    credentials_manager: &CredentialsManager,
    http_client: &Client,
    region: Region,
    season: &Uuid,
    query_args: HashMap<LeaderboardQueryArg, String>,
) -> Result<LeaderboardV1, RequestError> {
    //! Get the leaderboard of a region
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the leaderboard
    //! * `season` - The season of the leaderboard
    //! * `query_args` - The query arguments
    //! # Errors
    //! `RequestError` - If the request failed
    //! # Example
    //! ```rust no_run
    //! let season = Uuid::parse_str("34093c29-4306-43de-452f-3f944bde22be").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let queries = HashMap::new();
    //! let result = valorant_api::get_leaderboard_v1(credentials_manager, &http_client, region, &season, queries).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let queue = match credentials_manager.platform {
        Platform::PC => "competitive",
        Platform::XBOX | Platform::PlayStation => "console_competitive",
    };
    let mut url = Url::from_str(&format!(
        "https://pd.{}.a.pvp.net/mmr/v1/leaderboards/affinity/{}/queue/{}/season/{}",
        region.to_shard(),
        region,
        queue,
        season
    ))?;
    set_query_args(&mut url, query_args.into_iter());

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_store_offers_v1(
    credentials_manager: &CredentialsManager,
    http_client: &Client,
    region: Region,
) -> Result<StoreOffersV1, RequestError> {
    //! Get the store offers of a region
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the leaderboard
    //! # Errors
    //! `RequestError` - If the request failed
    //! # Example
    //! ```rust no_run
    //! let season = Uuid::parse_str("34093c29-4306-43de-452f-3f944bde22be").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let result = valorant_api::get_store_offers_v1(credentials_manager, &http_client, region).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let url = Url::from_str(&format!(
        "https://pd.{}.a.pvp.net/store/v1/offers/",
        region.to_shard(),
    ))?;

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_store_front_v2(
    credentials_manager: &CredentialsManager,
    http_client: &Client,
    region: Region,
    puuid: Uuid,
) -> Result<StoreFrontV2, RequestError> {
    //! Get the store front of a player
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `region` - The region of the leaderboard
    //! * `puuid` - The puuid of the player
    //! # Errors
    //! `RequestError` - If the request failed
    //! # Example
    //! ```rust no_run
    //! let puuid = Uuid::parse_str("34093c29-4306-43de-452f-3f944bde22be").expect("Invalid UUID");
    //! let region = Region::EU;
    //! let result = valorant_api::get_store_front_v1(credentials_manager, &http_client, region, puuid).await;
    //! println!("Result: {:#?}", result);
    //! ```

    let url = Url::from_str(&format!(
        "https://pd.{}.a.pvp.net/store/v2/storefront/{}",
        region.to_shard(),
        puuid,
    ))?;

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_account_aliases(
    credentials_manager: &CredentialsManager,
    http_client: &Client,
    cluster: &str,
    game_name: Option<&str>,
    tag_line: Option<&str>,
) -> Result<AccountAliasesV1, RequestError> {
    //! Get the account aliases of a player.
    //! This can be used to search for an account by game name and/or tag_line and get their puuid.
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `http_client` - The http client
    //! * `cluster` - The cluster of the player
    //! * `game_name` - The game name of the player
    //! * `tag_line` - The tag line of the player
    //! # Errors
    //! `RequestError` - If the request failed
    //! # Example
    //! ```rust no_run
    //! let result = valorant_api::get_account_aliases(credentials_manager, &http_client, "eu", None, None).await;
    //! println!("Result: {:#?}", result);
    //! ```
    let mut url = Url::from_str(&format!(
        "https://{}.api.account.riotgames.com/aliases/v1/aliases",
        cluster
    ))?;
    if let Some(game_name) = game_name {
        url.query_pairs_mut().append_pair("gameName", game_name);
    }
    if let Some(tag_line) = tag_line {
        url.query_pairs_mut().append_pair("tagLine", tag_line);
    }

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::new(),
    )
    .await
}

pub async fn get_esports_leagues(
    credentials_manager: &CredentialsManager,
    http_client: &Client,
    locale: EsportsLocales,
) -> Result<EsportsLeagues, RequestError> {
    //! Get all active valorant esports leagues.
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `http_client` - The http client
    //! * `locale` - The locale in which the leagues should be returned
    //! # Errors
    //! `RequestError` - If the request failed
    //! # Example
    //! ```rust no_run
    //! let result = valorant_api::get_esports_leagues(&credential_manager, &http_client, EsportsLocales::US).await;
    //! println!("Result: {:#?}", result);
    //! ```
    let url = Url::from_str(&format!(
        "https://esports-api.service.valorantesports.com/persisted/val/getLeagues?hl={}&sport=val",
        locale
    ))?;
    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::from([("x-api-key".to_string(), ESPORTS_API_KEY.to_string())]),
    )
    .await
}

pub async fn get_esports_schedule(
    credentials_manager: &CredentialsManager,
    http_client: &Client,
    locale: EsportsLocales,
) -> Result<EsportsSchedule, RequestError> {
    //! Get the schedule for all professional valorant games.
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `http_client` - The http client
    //! * `locale` - The locale in which the schedules should be returned
    //! # Errors
    //! `RequestError` - If the request failed
    //! # Example
    //! ```rust no_run
    //! let result = valorant_api::get_esports_schedule(&credential_manager, &http_client, EsportsLocales::US).await;
    //! println!("Result: {:#?}", result);
    //! ```
    let url = Url::from_str(&format!(
        "https://esports-api.service.valorantesports.com/persisted/val/getSchedule?hl={}&sport=val",
        locale
    ))?;

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::from([("x-api-key".to_string(), ESPORTS_API_KEY.to_string())]),
    )
    .await
}

pub async fn get_esports_vods(
    credentials_manager: &CredentialsManager,
    http_client: &Client,
    locale: EsportsLocales,
) -> Result<EsportsVod, RequestError> {
    //! Get the vod data for each game.
    //! # Arguments
    //! * `credentials_manager` - The credentials manager
    //! * `http_client` - The http client
    //! * `locale` - The locale in which the vod data should be returned
    //! # Errors
    //! `RequestError` - If the request failed
    //! # Example
    //! ```rust no_run
    //! let result = valorant_api::get_esports_vods(&credential_manager, &http_client, EsportsLocales::US).await;
    //! println!("Result: {:#?}", result);
    //! ```
    let url = Url::from_str(&format!(
        "https://esports-api.service.valorantesports.com/persisted/val/getVods?hl={}&sport=val",
        locale
    ))?;

    fetch_endpoint(
        credentials_manager,
        http_client,
        url,
        Method::GET,
        "",
        &HashMap::from([("x-api-key".to_string(), ESPORTS_API_KEY.to_string())]),
    )
    .await
}