ddapi-rs 2.0.0

A simple Rust library to get data from DDNet and DDStats APIs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use crate::api::{DDApi, DDstatsClient, HasApiCore};
use crate::error::Result;
use crate::scheme::ddstats::{Map, Player, Profile, StatsMap, Teero};
use std::future::Future;

pub trait DDstats {
    fn player(&self, player: &str) -> impl Future<Output = Result<Player>> + Send;
    fn map(&self, map: &str) -> impl Future<Output = Result<Map>> + Send;
    fn maps(&self) -> impl Future<Output = Result<Vec<StatsMap>>> + Send;
    fn profile(&self, player: &str) -> impl Future<Output = Result<Profile>> + Send;
    fn teero(&self, player: &str) -> impl Future<Output = Result<Teero>> + Send;
}

impl DDstats for DDApi {
    /// # Examples
    ///
    /// ```rust,ignore
    /// use ddapi_rs::prelude::*;
    /// use ddapi_rs::prelude::ddstats::*;
    ///
    /// let api = DDApi::new();
    /// let player: Player = api.player("Aoe").await?;
    /// println!("{}: {} | {}", player.profile.name, player.profile.points, player.profile.clan.unwrap_or(String::default()));
    /// ```
    async fn player(&self, player: &str) -> Result<Player> {
        self.generator(&Player::api(player)).await
    }

    /// # Examples
    ///
    /// ```rust,ignore
    /// use ddapi_rs::prelude::*;
    /// use ddapi_rs::prelude::ddstats::*;
    ///
    /// let api = DDApi::new();
    /// let map: Map = api.map("Fox").await?;
    /// println!("{}: {} | {}", map.info.map.map, map.info.map.stars, map.info.finishes);
    /// ```
    async fn map(&self, map: &str) -> Result<Map> {
        self.generator(&Map::api(map)).await
    }

    /// # Examples
    ///
    /// ```rust,ignore
    /// use ddapi_rs::prelude::*;
    /// use ddapi_rs::prelude::ddstats::*;
    ///
    /// let api = DDApi::new();
    /// let maps: Vec<StatsMap> = api.maps().await?;
    /// for map in &maps {
    ///     println!("{}: {} | {}", map.map, map.stars, map.points);
    /// }
    /// ```
    async fn maps(&self) -> Result<Vec<StatsMap>> {
        self.generator(&StatsMap::api()).await
    }

    /// # Examples
    ///
    /// ```rust,ignore
    /// use ddapi_rs::prelude::*;
    /// use ddapi_rs::prelude::ddstats::*;
    ///
    /// let api = DDApi::new();
    /// let player: Profile = api.profile("ByFox").await?;
    /// println!("{}: {}", player.name, player.clan.unwrap_or(String::default()));
    /// ```
    async fn profile(&self, player: &str) -> Result<Profile> {
        self.generator(&Profile::api(player)).await
    }

    /// # Examples
    ///
    /// ```rust,ignore
    /// use ddapi_rs::prelude::*;
    /// use ddapi_rs::prelude::ddstats::*;
    ///
    /// let api = DDApi::new();
    /// let teero: Teero = api.teero("Cor").await?;
    /// println!("{:?}", teero.most_played_maps_gametype);
    /// ```
    async fn teero(&self, player: &str) -> Result<Teero> {
        self.generator(&Teero::api(player)).await
    }
}

impl DDstats for DDstatsClient {
    async fn player(&self, player: &str) -> Result<Player> {
        self.core().generator(&Player::api(player)).await
    }

    async fn map(&self, map: &str) -> Result<Map> {
        self.core().generator(&Map::api(map)).await
    }

    async fn maps(&self) -> Result<Vec<StatsMap>> {
        self.core().generator(&StatsMap::api()).await
    }

    async fn profile(&self, player: &str) -> Result<Profile> {
        self.core().generator(&Profile::api(player)).await
    }

    async fn teero(&self, player: &str) -> Result<Teero> {
        self.core().generator(&Teero::api(player)).await
    }
}