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

use faceit::HttpClient;

#[tokio::main]
async fn main() -> Result<(), faceit::error::Error> {
    let client = HttpClient::new();

    // Example 1: Player API
    println!("=== Player API ===");
    let player = faceit::http::ergonomic::Player::new("player-id-here", &client);

    // Get player details
    match player.get().await {
        Ok(player_data) => {
            println!("Player: {}", player_data.nickname);
            if let Some(country) = player_data.country {
                println!("Country: {}", country);
            }
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Get player stats
    match player.stats("cs2").await {
        Ok(stats) => {
            println!("Stats retrieved for game: {}", stats.game_id);
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Get player match history
    match player.history("cs2", None, None, Some(0), Some(20)).await {
        Ok(history) => {
            println!("Found {} matches", history.items.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Get player hubs
    match player.hubs(Some(0), Some(50)).await {
        Ok(hubs) => {
            println!("Found {} hubs", hubs.items.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Example 2: Match API
    println!("\n=== Match API ===");
    let match_obj = faceit::http::ergonomic::Match::new("match-id-here", &client);

    match match_obj.get().await {
        Ok(match_data) => {
            println!("Match ID: {}", match_data.match_id);
            println!("Status: {}", match_data.status);
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    match match_obj.stats().await {
        Ok(stats) => {
            println!("Rounds: {}", stats.rounds.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Example 3: Game API
    println!("\n=== Game API ===");
    let game = faceit::http::ergonomic::Game::new("cs2", &client);

    match game.get().await {
        Ok(game_data) => {
            println!("Game: {}", game_data.long_label);
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    match game.matchmakings(Some("EU"), Some(0), Some(20)).await {
        Ok(matchmakings) => {
            println!("Found {} matchmakings", matchmakings.items.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Example 4: Hub API
    println!("\n=== Hub API ===");
    let hub = faceit::http::ergonomic::Hub::new("hub-id-here", &client);

    match hub.get(None).await {
        Ok(hub_data) => {
            println!("Hub: {}", hub_data.name);
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    match hub.matches(Some("all"), Some(0), Some(20)).await {
        Ok(matches) => {
            println!("Found {} matches", matches.items.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    match hub.members(Some(0), Some(50)).await {
        Ok(members) => {
            println!("Found {} members", members.items.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Example 5: Championship API
    println!("\n=== Championship API ===");
    let championship = faceit::http::ergonomic::Championship::new("championship-id-here", &client);

    match championship.get(None).await {
        Ok(championship_data) => {
            println!("Championship: {}", championship_data.name);
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    match championship.matches(Some("all"), Some(0), Some(20)).await {
        Ok(matches) => {
            println!("Found {} matches", matches.items.len());
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    // Example 6: Direct instantiation (alternative to client methods)
    println!("\n=== Direct Instantiation ===");
    use faceit::http::ergonomic::{Championship, Game, Hub, Match, Player};

    let _player2 = Player::new("player-id-here", &client);
    let _match_obj2 = Match::new("match-id-here", &client);
    let _game2 = Game::new("cs2", &client);
    let _hub2 = Hub::new("hub-id-here", &client);
    let _championship2 = Championship::new("championship-id-here", &client);

    println!("Created ergonomic API instances directly");

    Ok(())
}