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

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

use hyper::body::to_bytes;
use hyper::http::uri::{Scheme, Uri};

use serde::Deserialize;
use serde_xml_rs::from_str;

const AUTHORITY: &str = "steamcommunity.com";

#[derive(Deserialize, Debug)]
pub struct Group {
    #[serde(rename = "groupID64")]
    pub id: SteamID,
    #[serde(rename = "groupDetails")]
    pub details: GroupDetails,
    #[serde(rename = "memberCount")]
    pub member_count: u32,
}

#[derive(Deserialize, Debug)]
pub struct GroupDetails {
    #[serde(rename = "groupName")]
    pub name: String,
    #[serde(rename = "groupURL")]
    pub url: String,
    #[serde(rename = "headline")]
    pub headline: String,
    #[serde(rename = "summary")]
    pub summary: String,
    #[serde(rename = "avatarIcon")]
    pub avatar_icon: String,
    #[serde(rename = "avatarMedium")]
    pub avatar_medium: String,
    #[serde(rename = "avatarFull")]
    pub avatar_full: String,
    #[serde(rename = "membersInChat")]
    pub members_in_chat: u32,
    #[serde(rename = "membersInGame")]
    pub members_in_game: u32,
    #[serde(rename = "membersOnline")]
    pub members_online: u32,
}

impl SteamClient {
    /// Returns info about group by its id
    //
    // setting include_members to true will take a long time for a big group
    // and the return value will also be quite large. Thats why its false on default.
    pub async fn get_group_summary(
        &self,
        group_id: &SteamID,
        //include_members: Option<bool>,
    ) -> Result<Group> {
        let gid = SteamID3::from(*group_id).to_string();
        let path = format!(
            "/gid/{}/memberslistxml?xml=1",
            gid[5..gid.len() - 1].to_owned()
        );
        let uri = Uri::builder()
            .scheme(Scheme::HTTPS)
            .authority(AUTHORITY)
            .path_and_query(path)
            .build()?;

        let raw_response = self.client.get(uri).await?;
        let raw_body = raw_response.into_body();
        let stringified = String::from_utf8(to_bytes(raw_body).await?.to_vec())
            .map_err(|_| Error::client("unable to parse string from response"));
        let response: Group = from_str(&stringified?)?;

        Ok(response)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tokio_test::block_on;

    #[test]
    fn fetch_group_info() {
        let client = SteamClient::new();
        let group_id = SteamID::from(103582791456670032);
        let group_summary = block_on(client.get_group_summary(&group_id)).unwrap();
        println!("{:?}", group_summary)
    }
}