pubg-rs 0.0.2

beta public rust pubg 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

use reqwest::Client;
use structs::{ClanApiResponse, Player, PlayerByID, PlayersApiResponse, SeasonData, SeasonResponseApi};


mod structs;

pub struct PubgRs {
    key: &'static str
}

impl PubgRs {

    pub fn new(key: impl Into<&'static str>) -> Self {
        Self { key: key.into() }
    }


    pub async fn get_player(&self, nickname: &str) -> Option<Player> {
        let client = Client::new();
    
        let response = client
            .get(format!("https://api.pubg.com/shards/steam/players?filter[playerNames]={}", nickname))
            .header("Authorization", format!("Bearer {}", self.key))
            .header("Accept", "application/vnd.api+json")
            .send()
            .await.unwrap()
            .json::<PlayersApiResponse>().await;
    
    
            match response {
                Err(_) => None,
                Ok(player) => {

                    if player.data.len() >= 1 {
                        Some(player.data[0].clone())
                    }
                    else {None}
                }
            }
    
    }


    pub async fn get_player_by_id(&self, id: &str) -> Option<Player> {
        let client = Client::new();
    
        let response = client
            .get(format!("https://api.pubg.com/shards/steam/players/{}", id))
            .header("Authorization", format!("Bearer {}", self.key))
            .header("Accept", "application/vnd.api+json")
            .send()
            .await.unwrap()
            .json::<PlayerByID>()
            .await;
    
    
            match response {
                Err(_) => None,
                Ok(player) => Some(player.data)
            }
    
    }
    
    
    pub async fn get_clan(&self, id: &str) -> Option<ClanApiResponse> {
        let client = Client::new();
    
        let response = client
            .get(format!("https://api.pubg.com/shards/steam/clans/{}", id))
            .header("Authorization", format!("Bearer {}", self.key))
            .header("Accept", "application/vnd.api+json")
            .send()
            .await.unwrap()
            .json::<ClanApiResponse>()
            .await;
    
    
            match response {
                Err(_) => None,
                Ok(player) => Some(player)
            }
    
    }

    pub async fn get_season_info(&self, player_id: &str, season_id: &str) -> Option<SeasonData> {
        let client = Client::new();
    
        let response = client
            .get(format!("https://api.pubg.com/shards/steam/players/{}/seasons/{}/ranked", player_id, season_id))
            .header("Authorization", format!("Bearer {}", self.key))
            .header("Accept", "application/vnd.api+json")
            .send()
            .await.unwrap()
            
            .json::<SeasonResponseApi>()
            .await;
    
    
            match response {
                Err(err) => {
                    println!("Erro: {}", err);
                    None},
                Ok(player) => Some({
                    player.data
                })
            }
    
    }
    
}