mcsr-ranked-api 0.4.2

MCSR Ranked API wrapper in Rust
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
140
141
142
143
144
145
146
147
148
149
150

use serde::Serialize;
use std::ops::Not;

#[cfg(feature = "blocking")]
use crate::helpers::make_request_blocking;
use crate::{
	helpers::make_request,
	pagination::Pagination,
	types::{MatchId, Season},
	user::identifier::UserIdentifier,
	Result,
};

use super::{AdvancedMatchInfo, MatchInfo, MatchType};

const BASE_URL: &str = "https://api.mcsrranked.com/matches/{}";

impl AdvancedMatchInfo {
	pub async fn get_by_id(id: MatchId) -> Result<Self> {
		make_request(BASE_URL, [&id.to_string()], None::<&()>).await
	}
}

#[cfg(feature = "blocking")]
impl AdvancedMatchInfo {
	pub fn get_by_id_blocking(id: MatchId) -> Result<Self> {
		make_request_blocking(BASE_URL, [&id.to_string()], None::<&()>)
	}
}

const USER_URL: &str = "https://api.mcsrranked.com/users/{}/matches";

/// Parameters for [`UserIdentifier::get_user_matches`]
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize)]
#[serde(rename_all = "lowercase")]
pub struct GetMatchesParams {
	#[serde(flatten)]
	pub pagination: Pagination,
	#[serde(rename = "type")]
	pub kind: Option<MatchType>,
	pub season: Option<Season>,
	pub exclude_decay: bool,
}
impl From<Pagination> for GetMatchesParams {
	fn from(pagination: Pagination) -> Self {
		Self {
			pagination,
			..Default::default()
		}
	}
}

impl UserIdentifier<'_> {
	/// GET the user's matches by identifier using given `params`
	pub async fn get_matches(&self, params: Option<&GetMatchesParams>) -> Result<Box<[MatchInfo]>> {
		make_request(USER_URL, [&self.to_string()], params).await
	}
}

#[cfg(feature = "blocking")]
impl UserIdentifier<'_> {
	/// Synchronously GET the user's matches by identifier using given `params`
	pub fn get_matches_blocking(
		&self,
		params: Option<&GetMatchesParams>,
	) -> Result<Box<[MatchInfo]>> {
		make_request_blocking(USER_URL, [&self.to_string()], params)
	}
}

const RECENT_URL: &str = "https://api.mcsrranked.com/matches/";

/// Parameters for [`MatchInfo::get_recent`]
///
/// /// Note: this struct supports the builder pattern
///
/// # Examples
/// ```
/// use mcsr_ranked_api::game::requests::GetRecentMatchesParams;
/// use mcsr_ranked_api::game::MatchType;
/// let params = GetRecentMatchesParams::default()
///     .season(0)
///     .include_decay(true)
///     .kind(MatchType::Private);
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize)]
#[serde(rename_all = "lowercase")]
pub struct GetRecentMatchesParams<'a> {
	#[serde(flatten)]
	pub pagination: Pagination,
	#[serde(rename = "type")]
	pub kind: Option<MatchType>,
	pub tag: Option<&'a str>,
	pub season: Option<Season>,
	#[serde(rename = "includedecay")]
	#[serde(skip_serializing_if = "Not::not")]
	pub include_decay: bool,
}
impl From<Pagination> for GetRecentMatchesParams<'_> {
	fn from(pagination: Pagination) -> Self {
		Self {
			pagination,
			..Default::default()
		}
	}
}
impl<'a> GetRecentMatchesParams<'a> {
	/// Set the `pagination` field
	///
	/// Note: it is better to use `From<Pagination>`
	pub fn pagination(mut self, pagination: Pagination) -> Self {
		self.pagination = pagination;
		self
	}
	/// Set the `kind` field
	pub fn kind(mut self, kind: MatchType) -> Self {
		self.kind = Some(kind);
		self
	}
	/// Set the `tag` field
	pub fn tag(mut self, tag: &'a str) -> Self {
		self.tag = Some(tag);
		self
	}
	/// Set the `season` field
	pub fn season(mut self, season: Season) -> Self {
		self.season = Some(season);
		self
	}
	/// Set the `include_decay` field
	pub fn include_decay(mut self, include_decay: bool) -> Self {
		self.include_decay = include_decay;
		self
	}
}

impl MatchInfo {
	/// GET recent matches given `params`
	pub async fn get_recent(params: Option<&GetRecentMatchesParams<'_>>) -> Result<Box<[Self]>> {
		make_request(RECENT_URL, &[] as &[&str], params).await
	}
}

#[cfg(feature = "blocking")]
impl MatchInfo {
	/// Synchronously GET recent matches given `params`
	pub fn get_recent_blocking(params: Option<&GetRecentMatchesParams<'_>>) -> Result<Box<[Self]>> {
		make_request_blocking(RECENT_URL, &[] as &[&str], params)
	}
}