faceit 0.1.0

A Rust client library for the FACEIT Public 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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use crate::error::Error;
use crate::http::Client;
use crate::types::*;

/// High-level API for interacting with a specific hub
///
/// This struct provides a convenient way to work with hub data
/// without needing to pass the hub ID to each method call.
///
/// # Examples
///
/// ```no_run
/// # use faceit::{HttpClient, http::ergonomic::Hub};
/// # async fn example() -> Result<(), faceit::error::Error> {
/// let client = HttpClient::new();
/// let hub = Hub::new("hub-id-here", &client);
///
/// // Get hub details
/// let hub_data = hub.get(None).await?;
/// println!("Hub: {}", hub_data.name);
///
/// // Get hub matches
/// let matches = hub.matches(Some("all"), Some(0), Some(20)).await?;
/// # Ok(())
/// # }
/// ```
pub struct Hub<'a> {
    hub_id: String,
    client: &'a Client,
}

impl<'a> Hub<'a> {
    /// Create a new Hub instance
    ///
    /// # Arguments
    /// * `hub_id` - The hub ID
    /// * `client` - Reference to the FACEIT client
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use faceit::{HttpClient, http::ergonomic::Hub};
    /// let client = HttpClient::new();
    /// let hub = Hub::new("hub-id-here", &client);
    /// ```
    pub fn new(hub_id: impl Into<String>, client: &'a Client) -> Self {
        Self {
            hub_id: hub_id.into(),
            client,
        }
    }

    /// Get the hub's ID
    pub fn id(&self) -> &str {
        &self.hub_id
    }

    /// Get the hub's details
    ///
    /// # Arguments
    /// * `expanded` - Optional list of entities to expand (e.g., ["organizer", "game"])
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use faceit::{HttpClient, http::ergonomic::Hub};
    /// # async fn example() -> Result<(), faceit::error::Error> {
    /// let client = HttpClient::new();
    /// let hub = Hub::new("hub-id-here", &client);
    /// let hub_data = hub.get(None).await?;
    /// println!("Hub: {}", hub_data.name);
    /// # Ok(())
    /// # }
    /// ```
    pub async fn get(&self, expanded: Option<&[&str]>) -> Result<crate::types::Hub, Error> {
        self.client.get_hub(&self.hub_id, expanded).await
    }

    /// Get the hub's matches
    ///
    /// # Arguments
    /// * `match_type` - Optional match type filter ("all", "upcoming", "ongoing", "past")
    /// * `offset` - Optional offset for pagination (default: 0)
    /// * `limit` - Optional limit for pagination (default: 20, max: 100)
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use faceit::{HttpClient, http::ergonomic::Hub};
    /// # async fn example() -> Result<(), faceit::error::Error> {
    /// let client = HttpClient::new();
    /// let hub = Hub::new("hub-id-here", &client);
    /// let matches = hub.matches(Some("all"), Some(0), Some(20)).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn matches(
        &self,
        match_type: Option<&str>,
        offset: Option<i64>,
        limit: Option<i64>,
    ) -> Result<MatchesList, Error> {
        self.client
            .get_hub_matches(&self.hub_id, match_type, offset, limit)
            .await
    }

    /// Get the hub's members
    ///
    /// # Arguments
    /// * `offset` - Optional offset for pagination (default: 0, max: 1000)
    /// * `limit` - Optional limit for pagination (default: 50, max: 50)
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use faceit::{HttpClient, http::ergonomic::Hub};
    /// # async fn example() -> Result<(), faceit::error::Error> {
    /// let client = HttpClient::new();
    /// let hub = Hub::new("hub-id-here", &client);
    /// let members = hub.members(Some(0), Some(50)).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn members(
        &self,
        offset: Option<i64>,
        limit: Option<i64>,
    ) -> Result<HubMembers, Error> {
        self.client
            .get_hub_members(&self.hub_id, offset, limit)
            .await
    }

    /// Get the hub's statistics
    ///
    /// # Arguments
    /// * `offset` - Optional offset for pagination (default: 0)
    /// * `limit` - Optional limit for pagination (default: 20, max: 100)
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use faceit::{HttpClient, http::ergonomic::Hub};
    /// # async fn example() -> Result<(), faceit::error::Error> {
    /// let client = HttpClient::new();
    /// let hub = Hub::new("hub-id-here", &client);
    /// let stats = hub.stats(Some(0), Some(20)).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn stats(&self, offset: Option<i64>, limit: Option<i64>) -> Result<HubStats, Error> {
        self.client.get_hub_stats(&self.hub_id, offset, limit).await
    }
}