rust_of_clans/clans/
models.rs

1use std::collections::HashMap;
2
3use serde::{Deserialize, Serialize};
4
5/// Represents a Clash of Clans clan.
6#[derive(Serialize, Deserialize, Debug)]
7#[serde(rename_all = "camelCase")]
8pub struct Clan {
9    pub war_league: WarLeague,
10    pub capital_league: CapitalLeague,
11    pub member_list: Vec<ClanMember>,
12    pub tag: String,
13    pub clan_builder_base_points: i64,
14    pub clan_versus_points: i64,
15    pub war_wins: i64,
16    pub war_ties: i64,
17    pub war_losses: i64,
18    pub clan_points: i64,
19    pub required_town_hall_level: Option<i64>,
20    pub chat_language: Language,
21    pub is_family_friendly: bool,
22    pub clan_capital_points: i64,
23    pub required_trophies: i64,
24    pub required_builder_base_trophies: i64,
25    pub required_versus_trophies: i64,
26    pub is_war_log_public: bool,
27    pub war_frequency: WarFrequency,
28    pub clan_level: i64,
29    pub war_win_streak: i64,
30    pub labels: Vec<Label>,
31    pub name: String,
32    pub location: Location,
33    pub description: String,
34    pub members: i64,
35    pub r#type: ClanType,
36    pub clan_capital: ClanCapital,
37}
38
39/// Represents a member of a Clash of Clans clan.
40#[derive(Serialize, Deserialize, Debug)]
41#[serde(rename_all = "camelCase")]
42pub struct ClanMember {
43    pub league: League,
44    pub builder_base_league: BuilderBaseLague,
45    pub versus_trophies: i64,
46    pub tag: String,
47    pub name: String,
48    pub role: ClanMemberRole,
49    pub exp_level: i64,
50    pub clan_rank: i64,
51    pub previous_clan_rank: i64,
52    pub donations: i64,
53    pub donations_received: i64,
54    pub trophies: i64,
55    pub builder_base_trophies: i64,
56    pub player_house: Option<PlayerHouse>,
57}
58
59/// Represents a league in Clash of Clans.
60#[derive(Serialize, Deserialize, Debug)]
61#[serde(rename_all = "camelCase")]
62pub struct League {
63    pub name: String,
64    pub id: i64,
65    pub icon_urls: HashMap<String, String>,
66}
67
68/// Represents the builder base league of a Clash of Clans player.
69#[derive(Serialize, Deserialize, Debug)]
70pub struct BuilderBaseLague {
71    pub name: String,
72    pub id: i64,
73}
74
75/// Represents the war league of a Clash of Clans clan.
76#[derive(Serialize, Deserialize, Debug)]
77pub struct WarLeague {
78    pub name: String,
79    pub id: i64,
80}
81
82/// Represents the capital league of a Clash of Clans clan.
83#[derive(Serialize, Deserialize, Debug)]
84pub struct CapitalLeague {
85    pub name: String,
86    pub id: i64,
87}
88
89/// Represents the player's house in Clash of Clans.
90#[derive(Serialize, Deserialize, Debug)]
91pub struct PlayerHouse {
92    pub elements: Vec<PlayerHouseElement>,
93}
94
95/// Represents an element in the player's house in Clash of Clans.
96#[derive(Serialize, Deserialize, Debug)]
97pub struct PlayerHouseElement {
98    pub id: i64,
99    pub r#type: PlayerHouseElementType,
100}
101
102/// Represents the type of the Clash of Clans clan.
103#[derive(Debug, Serialize, Deserialize)]
104pub enum ClanType {
105    #[serde(rename = "open")]
106    Open,
107    #[serde(rename = "inviteOnly")]
108    InviteOnly,
109    #[serde(rename = "closed")]
110    Closed,
111}
112
113/// Represents the role of a member in a Clash of Clans clan.
114#[derive(Debug, Serialize, Deserialize)]
115pub enum ClanMemberRole {
116    #[serde(rename = "notMember")]
117    NotMember,
118    #[serde(rename = "member")]
119    Member,
120    #[serde(rename = "leader")]
121    Leader,
122    #[serde(rename = "admin")]
123    Admin,
124    #[serde(rename = "coLeader")]
125    CoLeader,
126}
127
128/// Represents the type of an element in the player's house in Clash of Clans.
129#[derive(Debug, Serialize, Deserialize)]
130pub enum PlayerHouseElementType {
131    #[serde(rename = "ground")]
132    Ground,
133    #[serde(rename = "roof")]
134    Roof,
135    #[serde(rename = "foot")]
136    Foot,
137    #[serde(rename = "decoration")]
138    Decoration,
139    #[serde(rename = "walls")]
140    Walls,
141}
142
143/// Represents the language of a Clash of Clans chat.
144#[derive(Serialize, Deserialize, Debug)]
145#[serde(rename_all = "camelCase")]
146pub struct Language {
147    pub name: String,
148    pub id: i64,
149    pub language_code: String,
150}
151
152/// Represents the war frequency of a Clash of Clans clan.
153#[derive(Serialize, Deserialize, Debug)]
154pub enum WarFrequency {
155    #[serde(rename = "unknown")]
156    Unknown,
157    #[serde(rename = "always")]
158    Always,
159    #[serde(rename = "moreThanOncePerWeek")]
160    MoreThanOncePerWeek,
161    #[serde(rename = "oncePerWeek")]
162    OncePerWeek,
163    #[serde(rename = "lessThanOncePerWeek")]
164    LessThanOncePerWeek,
165    #[serde(rename = "never")]
166    Never,
167    #[serde(rename = "any")]
168    Any,
169}
170
171/// Represents a label in a Clash of Clans clan.
172#[derive(Serialize, Deserialize, Debug)]
173#[serde(rename_all = "camelCase")]
174pub struct Label {
175    pub name: String,
176    pub id: i64,
177    pub badge_urls: Option<HashMap<String, String>>,
178}
179
180/// Represents the clan capital in Clash of Clans.
181#[derive(Serialize, Deserialize, Debug)]
182#[serde(rename_all = "camelCase")]
183pub struct ClanCapital {
184    pub capital_hall_level: i64,
185    pub districts: Vec<ClanDistrictData>,
186}
187
188/// Represents a district in the clan capital of Clash of Clans.
189#[derive(Serialize, Deserialize, Debug)]
190#[serde(rename_all = "camelCase")]
191pub struct ClanDistrictData {
192    pub name: String,
193    pub id: i64,
194    pub district_hall_level: i64,
195}
196
197/// Represents the location of a Clash of Clans clan or player.
198#[derive(Serialize, Deserialize, Debug)]
199#[serde(rename_all = "camelCase")]
200pub struct Location {
201    pub localized_name: Option<String>,
202    pub id: i64,
203    pub name: String,
204    pub is_country: bool,
205    pub country_code: String,
206}
207
208#[derive(Serialize, Deserialize, Debug)]
209pub struct ClanWarLeagueGroup {
210    pub tag: Option<String>,
211    pub state: ClanWarLeagueGroupState,
212    pub season: Option<String>,
213    pub clans: Option<Vec<ClanWarLeagueClan>>,
214    pub rounds: Option<Vec<ClanWarLeagueRound>>,
215}
216
217#[derive(Serialize, Deserialize, Debug)]
218pub enum ClanWarLeagueGroupState {
219    #[serde(rename = "groupNotFound")]
220    GroupNotFound,
221    #[serde(rename = "notInWar")]
222    NotInWar,
223    #[serde(rename = "preparation")]
224    Preparation,
225    #[serde(rename = "inWar")]
226    InWar,
227    #[serde(rename = "ended")]
228    Ended,
229}
230
231#[derive(Serialize, Deserialize, Debug)]
232#[serde(rename_all = "camelCase")]
233pub struct ClanWarLeagueClan {
234    pub tag: String,
235    pub clan_level: i64,
236    pub name: String,
237    pub members: Vec<ClanWarLeagueClanMember>,
238    pub badge_urls: HashMap<String, String>,
239}
240
241#[derive(Serialize, Deserialize, Debug)]
242#[serde(rename_all = "camelCase")]
243pub struct ClanWarLeagueClanMember {
244    pub tag: String,
245    pub town_hall_level: i64,
246    pub name: String,
247}
248
249#[derive(Serialize, Deserialize, Debug)]
250#[serde(rename_all = "camelCase")]
251pub struct ClanWarLeagueRound {
252    pub war_tags: Vec<String>,
253}
254
255#[derive(Serialize, Deserialize, Debug)]
256#[serde(rename_all = "camelCase")]
257pub struct ClanWarLogEntry {
258    pub clan: WarClan,
259    pub team_size: i64,
260    pub attacks_per_member: i64,
261    pub opponent: WarClan,
262    pub end_time: String,
263    pub result: Option<ClanWarResult>,
264}
265
266#[derive(Serialize, Deserialize, Debug)]
267#[serde(rename_all = "camelCase")]
268pub struct WarClan {
269    pub destruction_percentage: f64,
270    pub tag: Option<String>,
271    pub name: Option<String>,
272    pub badge_urls: HashMap<String, String>,
273    pub clan_level: i64,
274    pub attacks: Option<i64>,
275    pub stars: i64,
276    pub exp_earned: Option<i64>,
277    pub members: Option<Vec<ClanWarMember>>,
278}
279
280#[derive(Serialize, Deserialize, Debug)]
281#[serde(rename_all = "camelCase")]
282pub struct ClanWarMember {
283    pub tag: String,
284    pub name: String,
285    pub map_position: i64,
286    pub town_hall_level: i64,
287    pub opponent_attacks: i64,
288    pub best_opponent_attack: ClanWarAttack,
289    pub attacks: Vec<ClanWarAttack>,
290}
291
292#[derive(Serialize, Deserialize, Debug)]
293#[serde(rename_all = "camelCase")]
294pub struct ClanWarAttack {
295    pub order: i64,
296    pub attacker_tag: String,
297    pub defender_tag: String,
298    pub stars: i64,
299    pub destruction_percentage: i64,
300    pub duration: i64,
301}
302
303#[derive(Serialize, Deserialize, Debug)]
304pub enum ClanWarResult {
305    #[serde(rename = "lose")]
306    Lose,
307    #[serde(rename = "win")]
308    NotInWar,
309    #[serde(rename = "tie")]
310    Preparation,
311}
312
313#[derive(Serialize, Deserialize, Debug)]
314#[serde(rename_all = "camelCase")]
315pub struct ClanWar {
316    pub clan: WarClan,
317    pub team_size: Option<i64>,
318    pub attacks_per_member: Option<i64>,
319    pub opponent: WarClan,
320    pub start_time: Option<String>,
321    pub state: ClanWarState,
322    pub end_time: Option<String>,
323    pub preparation_start_time: Option<String>,
324}
325
326#[derive(Serialize, Deserialize, Debug)]
327pub enum ClanWarState {
328    #[serde(rename = "clanNotFound")]
329    ClanNotFound,
330    #[serde(rename = "accessDenied")]
331    AccessDenied,
332    #[serde(rename = "notInWar")]
333    NotInWar,
334    #[serde(rename = "inMatchmaking")]
335    InMatchMaking,
336    #[serde(rename = "enterWar")]
337    EnterWar,
338    #[serde(rename = "matched")]
339    Matched,
340    #[serde(rename = "preparation")]
341    Preparation,
342    #[serde(rename = "war")]
343    War,
344    #[serde(rename = "inWar")]
345    InWar,
346    #[serde(rename = "ended")]
347    Ended,
348}
349
350#[derive(Serialize, Deserialize, Debug)]
351#[serde(rename_all = "camelCase")]
352pub struct ClanCapitalRaidSeason {
353    pub attack_log: Vec<ClanCapitalRaidSeasonAttackLogEntry>,
354    pub defense_log: Vec<ClanCapitalRaidSeasonDefenseLogEntry>,
355    pub state: String,
356    pub start_rime: Option<String>,
357    pub end_time: String,
358    pub capital_total_loot: i64,
359    pub raids_completed: i64,
360    pub total_attacks: i64,
361    pub enemy_districts_destroyed: i64,
362    pub offensive_reward: i64,
363    pub defensive_reward: i64,
364    pub members: Option<Vec<ClanCapitalRaidSeasonMember>>,
365}
366
367#[derive(Serialize, Deserialize, Debug)]
368#[serde(rename_all = "camelCase")]
369pub struct ClanCapitalRaidSeasonAttackLogEntry {
370    pub defender: ClanCapitalRaidSeasonClanInfo,
371    pub attack_count: i64,
372    pub district_count: i64,
373    pub districts_destroyed: i64,
374    pub districts: Vec<ClanCapitalRaidSeasonDistrict>,
375}
376
377#[derive(Serialize, Deserialize, Debug)]
378#[serde(rename_all = "camelCase")]
379pub struct ClanCapitalRaidSeasonClanInfo {
380    pub tag: String,
381    pub name: String,
382    pub level: i64,
383    pub badge_urls: HashMap<String, String>,
384}
385
386#[derive(Serialize, Deserialize, Debug)]
387#[serde(rename_all = "camelCase")]
388pub struct ClanCapitalRaidSeasonDistrict {
389    pub stars: i64,
390    pub name: String,
391    pub id: i64,
392    pub destruction_percent: i64,
393    pub attack_count: i64,
394    pub total_looted: i64,
395    pub attacks: Option<Vec<ClanCapitalRaidSeasonAttack>>,
396    pub district_hall_level: i64,
397}
398
399#[derive(Serialize, Deserialize, Debug)]
400#[serde(rename_all = "camelCase")]
401pub struct ClanCapitalRaidSeasonAttack {
402    pub attacker: ClanCapitalRaidSeasonAttacker,
403    pub destruction_percent: i64,
404    pub stars: i64,
405}
406
407#[derive(Serialize, Deserialize, Debug)]
408pub struct ClanCapitalRaidSeasonAttacker {
409    pub tag: String,
410    pub name: String,
411}
412
413#[derive(Serialize, Deserialize, Debug)]
414#[serde(rename_all = "camelCase")]
415pub struct ClanCapitalRaidSeasonMember {
416    pub tag: String,
417    pub name: String,
418    pub attacks: i64,
419    pub attack_limit: i64,
420    pub bonus_attack_limit: i64,
421    pub capital_resources_looted: i64,
422}
423
424#[derive(Serialize, Deserialize, Debug)]
425#[serde(rename_all = "camelCase")]
426pub struct ClanCapitalRaidSeasonDefenseLogEntry {
427    pub attacker: ClanCapitalRaidSeasonClanInfo,
428    pub attack_count: i64,
429    pub district_count: i64,
430    pub districts_destroyed: i64,
431    pub districts: Vec<ClanCapitalRaidSeasonDistrict>,
432}
rust_of_clans/clans/models.rs

rust_of_clans/clans/
models.rs
