rsteam 0.2.1

rsteam is a easy to use async wrapper for the steam web api
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

use std::num::NonZeroU32;

use crate::error::Error;
use crate::utils::{Result, AUTHORITY};
use crate::{SteamClient, SteamID};

use hyper::body::to_bytes;
use hyper::Uri;

use serde::Deserialize;
use serde_json::from_slice;

const PATH: &str = "/ISteamUserStats/GetUserStatsForGame/v0002";

#[derive(Deserialize, Debug)]
pub struct Stat {
    pub name: String,
    pub value: u32,
}

#[derive(Deserialize, Debug)]
pub struct Achievement {
    pub name: String,
    pub achieved: u32,
}

#[derive(Deserialize)]
struct Response {
    playerstats: PlayerStats,
}

#[derive(Deserialize)]
pub struct PlayerStats {
    #[serde(rename = "steamID")]
    pub id: SteamID,
    #[serde(rename = "gameName")]
    pub game_name: String,
    pub stats: Vec<Stat>,
    pub achievements: Vec<Achievement>,
}

impl SteamClient {
    /// Gets users [PlayerStats] for given game
    ///
    /// Requires an API key.
    pub async fn get_user_stats_for_game(
        &self,
        id: &SteamID,
        game_id: NonZeroU32,
    ) -> Result<PlayerStats> {
        let api_key = self
            .api_key
            .as_ref()
            .ok_or_else(|| Error::client("API key required"))?;

        let query = format!("key={}&steamid={}&appid={}", api_key, id, game_id);
        let uri = Uri::builder()
            .scheme("https")
            .authority(AUTHORITY)
            .path_and_query(format!("{}?{}", PATH, query))
            .build()?;

        let response = self.client.get(uri).await?;
        let body = response.into_body();
        let parsed = from_slice::<Response>(&to_bytes(body).await?)?;

        Ok(parsed.playerstats)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::env;

    #[test]
    fn fetch_stats() {
        let client = SteamClient::with_api_key(&env::var("STEAM_API_KEY").unwrap());
        let id = SteamID::from(76561198061271782);
        let game_id = NonZeroU32::new(730).unwrap();
        let player_stats =
            tokio_test::block_on(client.get_user_stats_for_game(&id, game_id)).unwrap();

        for stat in &player_stats.stats {
            println!("{:?}", stat)
        }
        for achievement in &player_stats.achievements {
            println!("{:?}", achievement)
        }
        assert!(!player_stats.stats.is_empty());
        assert!(!player_stats.achievements.is_empty());
    }
}