riot-api 0.1.2

A rust crate to interact with Riot Games Developer 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

use std::collections::HashMap;
use std::fmt::{Display, Formatter};
use serde::Deserialize;

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ChallengeConfigInfoDto {
    pub id: u64,
    pub localized_names: HashMap<String, HashMap<String, String>>,
    pub state: ChallengeState,
    pub tracking: ChallengeTracking,
    pub start_timestamp: i64,
    pub end_timestamp: i64,
    pub leaderboard: bool,
    pub thresholds: HashMap<String, f64>,
}

#[derive(Debug, Deserialize, Eq, PartialEq)]
#[serde(rename_all = "UPPERCASE")]
pub enum ChallengeState {
    Disabled,
    Hidden,
    Enabled,
    Archived,
}

#[derive(Debug, Deserialize, Eq, PartialEq)]
#[serde(rename_all = "UPPERCASE")]
pub enum ChallengeTracking {
    Lifetime,
    Season
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ApexPlayerInfoDto {
    pub puuid: String,
    pub value: f64,
    pub position: u32,
}

#[derive(Debug, Deserialize, Eq, PartialEq, Hash)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum ChallengeLevel {
    None,
    Iron,
    Bronze,
    Silver,
    Gold,
    Platinum,
    Diamond,
    Master,
    Grandmaster,
    Challenger,
    HighestNotLeaderboardOnly,
    Highest,
    Lowest
}
impl Display for ChallengeLevel {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
       let result = match self {
           ChallengeLevel::None => "NONE",
           ChallengeLevel::Iron => "IRON",
           ChallengeLevel::Bronze => "BRONZE",
           ChallengeLevel::Silver => "SILVER",
           ChallengeLevel::Gold => "GOLD",
           ChallengeLevel::Platinum => "PLATINUM",
           ChallengeLevel::Diamond => "DIAMOND",
           ChallengeLevel::Master => "MASTER",
           ChallengeLevel::Grandmaster => "GRANDMASTER",
           ChallengeLevel::Challenger => "CHALLENGER",
           ChallengeLevel::HighestNotLeaderboardOnly => "HIGHEST_NOT_LEADERBOARD_ONLY",
           ChallengeLevel::Highest => "HIGHEST",
           ChallengeLevel::Lowest => "LOWEST",
       };

        write!(f, "{result}")
    }
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PlayerInfoDto {
    pub challenges: Vec<ChallengeInfo>,
    pub preferences: PlayerClientPreferences,
    pub total_points: ChallengePoints,
    pub category_points: HashMap<String, ChallengeInfo>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ChallengeInfo {
    pub challenge_id: u64,
    pub percentile: f64,
    pub level: ChallengeLevel,
    pub value: f64,
    pub achieved_time: i64,
    pub position: i64,
    pub players_in_level: i64,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PlayerClientPreferences {
    pub banner_accent: String,
    pub title: String,
    pub challenge_ids: Vec<u64>,
    pub crest_border: String,
    pub prestige_crest_border_level: i32,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ChallengePoints {
    pub level: ChallengeLevel,
    pub current: i64,
    pub max: i64,
    pub percentile: f64,
}