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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
use serde::{
Deserialize,
Serialize,
};
use crate::{
entrant::*,
event::*,
participant::*,
phase::*,
phase_group::*,
player::*,
set::*,
tournament::*,
user::*,
videogame::*,
};
/// Equivalent for start.gg Query.
///
/// Each element in the structure is optional, allowing a user to only query values they want.
/// Given each is an option and not a requirement, a method is included for each element with the same name.
/// These methods will unwrap and return the proper value without any unwrapping or references needed.
/// Certain methods (see tournaments()) will return a vector of the data type instead of a connection to a vector, done to simplify the API and make the start.gg api easier to work with.
#[derive(Clone, Serialize, Deserialize)]
pub struct GGData {
#[serde(rename(serialize = "currentUser", deserialize = "currentUser"))]
pub current_user: Option<Box<GGUser>>,
pub entrant: Option<Box<GGEntrant>>,
pub event: Option<Box<GGEvent>>,
// pub league: Option<league::GGLeague>,
// pub leagues: Option<league::GGLeagues>,
pub participant: Option<Box<GGParticipant>>,
pub phase: Option<Box<GGPhase>>,
#[serde(rename(serialize = "phaseGroup", deserialize = "phaseGroup"))]
pub phase_group: Option<Box<GGPhaseGroup>>,
pub player: Option<Box<GGPlayer>>,
// pub seed: Option<seed::GGSeed>,
pub set: Option<Box<GGSet>>,
// pub shop: Option<shop::GGShop>,
// pub stream: Option<streams::GGStreams>,
// pub stream_queue: Option<stream_queue::GGStreamQueue>,
// pub team: Option<team::GGTeam>,
pub tournament: Option<Box<GGTournament>>,
pub tournaments: Option<Box<GGTournamentConnection>>,
pub user: Option<Box<GGUser>>,
pub videogame: Option<Box<GGVideogame>>,
pub videogames: Option<Box<GGVideogameConnection>>,
}
impl GGData {
/// Returns the current user.
///
/// Returns an empty user if not set or wasn't queried.
pub fn current_user(&self) -> GGUser {
let mut result: GGUser = Default::default();
if self.current_user.is_some() {
result = *self.current_user.as_ref().unwrap().clone();
}
return result;
}
/// Returns the entrant.
///
/// Returns an empty entrant if not set or wasn't queried.
pub fn entrant(&self) -> GGEntrant {
let mut result: GGEntrant = Default::default();
if self.entrant.is_some() {
result = *self.entrant.as_ref().unwrap().clone();
}
return result;
}
/// Returns the event.
///
/// Returns an empty event if not set or wasn't queried.
pub fn event(&self) -> GGEvent {
let mut result: GGEvent = Default::default();
if self.event.is_some() {
result = *self.event.as_ref().unwrap().clone();
}
return result;
}
/// Returns the participant.
///
/// Returns an empty participant if not set or wasn't queried.
pub fn participant(&self) -> GGParticipant {
let mut result: GGParticipant = Default::default();
if self.participant.is_some() {
result = *self.participant.as_ref().unwrap().clone();
}
return result;
}
/// Returns the phase.
///
/// Returns an empty phase if not set or wasn't queried.
pub fn phase(&self) -> GGPhase {
let mut result: GGPhase = Default::default();
if self.phase.is_some() {
result = *self.phase.as_ref().unwrap().clone();
}
return result;
}
/// Returns the phase group.
///
/// Returns an empty phase group if not set or wasn't queried.
pub fn phase_group(&self) -> GGPhaseGroup {
let mut result: GGPhaseGroup = Default::default();
if self.phase_group.is_some() {
result = *self.phase_group.as_ref().unwrap().clone();
}
return result;
}
/// Returns the player.
///
/// Returns an empty player if not set or wasn't queried.
pub fn player(&self) -> GGPlayer {
let mut result: GGPlayer = Default::default();
if self.player.is_some() {
result = *self.player.as_ref().unwrap().clone();
}
return result;
}
/// Returns the set.
///
/// Returns an empty set if not set or wasn't queried.
pub fn set(&self) -> GGSet {
let mut result: GGSet = Default::default();
if self.set.is_some() {
result = *self.set.as_ref().unwrap().clone();
}
return result;
}
/// Returns the tournament.
///
/// Returns an empty tournament if not set or wasn't queried.
pub fn tournament(&self) -> GGTournament {
let mut result: GGTournament = Default::default();
if self.tournament.is_some() {
result = *self.tournament.as_ref().unwrap().clone();
}
return result;
}
/// Returns a vector of tournaments.
///
/// Returns an empty vector if not set or wasn't queried.
pub fn tournaments(&self) -> Vec<GGTournament> {
let mut result: Vec<GGTournament> = Vec::new();
if self.tournaments.is_some() {
for tournament in &self.tournaments.as_ref().unwrap().nodes {
result.push(tournament.clone());
}
}
return result;
}
/// Returns the user.
///
/// Returns an empty user if not set or wasn't queried.
pub fn user(&self) -> GGUser {
let mut result: GGUser = Default::default();
if self.user.is_some() {
result = *self.user.as_ref().unwrap().clone();
}
return result;
}
/// Returns the videogame.
///
/// Returns an empty videogame if not set or wasn't queried.
pub fn videogame(&self) -> GGVideogame {
let mut result: GGVideogame = Default::default();
if self.videogame.is_some() {
result = *self.videogame.as_ref().unwrap().clone();
}
return result;
}
/// Returns a vector of videogames.
///
/// Returns an empty vector if not set or wasn't queried.
pub fn videogames(&self) -> Vec<GGVideogame> {
let mut result: Vec<GGVideogame> = Vec::new();
if self.videogames.is_some() {
for videogame in &self.videogames.as_ref().unwrap().nodes {
result.push(videogame.clone());
}
}
return result;
}
}