use common::Date;
use disciplines::DisciplineId;
use matches::{MatchFormat, MatchType};
use participants::ParticipantType;
use streams::Streams;
#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
pub struct TournamentId(pub String);
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum TournamentStatus {
Setup,
Running,
Pending,
Completed,
}
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
pub struct Tournament {
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<TournamentId>,
pub discipline: DisciplineId,
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub full_name: Option<String>,
pub status: TournamentStatus,
#[serde(skip_serializing_if = "Option::is_none")]
pub date_start: Option<Date>,
#[serde(skip_serializing_if = "Option::is_none")]
pub date_end: Option<Date>,
#[serde(rename = "timezone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub time_zone: Option<String>,
pub online: bool,
pub public: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub country: Option<String>,
pub size: i64,
#[serde(skip_serializing_if = "Option::is_none")]
pub participant_type: Option<ParticipantType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub match_type: Option<MatchType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub organization: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub website: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rules: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub prize: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub team_size_min: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub team_size_max: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub streams: Option<Streams>,
#[serde(skip_serializing_if = "Option::is_none")]
pub check_in: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub participant_nationality: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub match_format: Option<MatchFormat>,
}
impl Tournament {
pub fn new<S: Into<String>>(
id: Option<TournamentId>,
discipline: DisciplineId,
name: S,
status: TournamentStatus,
online: bool,
public: bool,
size: i64,
) -> Tournament {
Tournament {
id,
discipline,
name: name.into(),
full_name: None,
status,
date_start: None,
date_end: None,
time_zone: None,
online,
public,
location: None,
country: None,
size,
participant_type: None,
match_type: None,
organization: None,
website: None,
description: None,
rules: None,
prize: None,
team_size_min: None,
team_size_max: None,
streams: None,
check_in: None,
participant_nationality: None,
match_format: None,
}
}
pub fn create<S: Into<String>>(
discipline: DisciplineId,
name: S,
size: i64,
participant_type: ParticipantType,
) -> Tournament {
Tournament {
id: None,
discipline,
name: name.into(),
full_name: None,
status: TournamentStatus::Setup,
date_start: None,
date_end: None,
time_zone: None,
online: true,
public: false,
location: None,
country: None,
size,
participant_type: Some(participant_type),
match_type: None,
organization: None,
website: None,
description: None,
rules: None,
prize: None,
team_size_min: None,
team_size_max: None,
streams: None,
check_in: None,
participant_nationality: None,
match_format: None,
}
}
builder!(id, Option<TournamentId>);
builder!(discipline, DisciplineId);
builder_s!(name);
builder_so!(full_name);
builder!(status, TournamentStatus);
builder!(date_start, Option<Date>);
builder!(date_end, Option<Date>);
builder_so!(time_zone);
builder!(online, bool);
builder!(public, bool);
builder_so!(location);
builder_so!(country);
builder!(size, i64);
builder!(participant_type, Option<ParticipantType>);
builder!(match_type, Option<MatchType>);
builder_so!(organization);
builder_so!(website);
builder_so!(description);
builder_so!(rules);
builder_so!(prize);
builder!(team_size_min, Option<i64>);
builder!(team_size_max, Option<i64>);
builder!(streams, Option<Streams>);
builder!(check_in, Option<bool>);
builder!(participant_nationality, Option<bool>);
builder!(match_format, Option<MatchFormat>);
}
impl Tournament {
pub fn iter<'a>(&self, client: &'a ::Toornament) -> Option<::TournamentIter<'a>> {
match self.id.clone() {
Some(id) => {
Some(::TournamentIter::new(client, id).with_streams(self.streams.is_some()))
}
None => None,
}
}
pub fn into_iter(self, client: &::Toornament) -> Option<::TournamentIter<'_>> {
match self.id {
Some(id) => {
Some(::TournamentIter::new(client, id).with_streams(self.streams.is_some()))
}
None => None,
}
}
}
#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
pub struct Tournaments(pub Vec<Tournament>);
#[cfg(test)]
mod tests {
use *;
#[test]
fn test_stream_parse() {
let string = r#"
{
"id": "56742bc7cc3c17ee608b4567",
"name": "DreamhackCS",
"url": "http://www.twitch.tv/dreamhackcs",
"language": "en"
}"#;
let d: Stream = serde_json::from_str(string).unwrap();
assert_eq!(d.id.0, "56742bc7cc3c17ee608b4567");
assert_eq!(d.name, "DreamhackCS");
assert_eq!(d.url, "http://www.twitch.tv/dreamhackcs");
assert_eq!(d.language, "en");
}
#[test]
fn test_tournament_parse() {
use chrono::Datelike;
let string = r#"
{
"id": "5608fd12140ba061298b4569",
"discipline": "my_discipline",
"name": "My Weekly Tournament",
"full_name": "My Weekly Tournament - Long title",
"status": "running",
"date_start": "2015-09-06",
"date_end": "2015-09-07",
"timezone": "America/Sao_Paulo",
"online": true,
"public": true,
"location": "London",
"country": "UK",
"size": 16,
"participant_type": "team",
"match_type": "duel",
"organization": "Avery Bullock",
"website": "http://www.toornament.com",
"description": "My description \n on multiple lines",
"rules": "My rules \n on multiple lines",
"prize": "1 - 10,000$ \n 2 - 5,000$",
"streams": [
{
"id": "56742bc7cc3c17ee608b4567",
"name": "DreamhackCS",
"url": "http://www.twitch.tv/dreamhackcs",
"language": "en"
}
],
"check_in": true,
"participant_nationality": true,
"match_format": "bo3"
}"#;
let t: Tournament = serde_json::from_str(string).unwrap();
assert_eq!(t.id.clone().unwrap().0, "5608fd12140ba061298b4569");
assert_eq!(t.discipline.0, "my_discipline");
assert_eq!(t.name, "My Weekly Tournament");
assert_eq!(t.status, TournamentStatus::Running);
assert!(t.date_start.is_some());
let date_start = t.date_start.clone().unwrap();
assert_eq!(date_start.year(), 2015i32);
assert_eq!(date_start.month(), 9u32);
assert_eq!(date_start.day(), 6u32);
assert!(t.date_end.is_some());
let date_end = t.date_end.clone().unwrap();
assert_eq!(date_end.year(), 2015i32);
assert_eq!(date_end.month(), 9u32);
assert_eq!(date_end.day(), 7u32);
assert_eq!(t.time_zone, Some("America/Sao_Paulo".to_owned()));
assert_eq!(t.online, true);
assert_eq!(t.public, true);
assert_eq!(t.location, Some("London".to_owned()));
assert_eq!(t.country, Some("UK".to_owned()));
assert_eq!(t.size, 16i64);
assert_eq!(t.participant_type, Some(ParticipantType::Team));
assert_eq!(t.match_type, Some(MatchType::Duel));
assert_eq!(t.organization, Some("Avery Bullock".to_owned()));
assert_eq!(t.website, Some("http://www.toornament.com".to_owned()));
assert_eq!(
t.description,
Some("My description \n on multiple lines".to_owned())
);
assert_eq!(t.rules, Some("My rules \n on multiple lines".to_owned()));
assert_eq!(t.prize, Some("1 - 10,000$ \n 2 - 5,000$".to_owned()));
assert!(t.streams.is_some());
let streams = t.streams.clone().unwrap();
assert_eq!(streams.0.len(), 1);
let stream_opt = streams.0.first();
assert!(stream_opt.is_some());
let stream = stream_opt.unwrap();
assert_eq!(stream.id, StreamId("56742bc7cc3c17ee608b4567".to_owned()));
assert_eq!(stream.name, "DreamhackCS");
assert_eq!(stream.url, "http://www.twitch.tv/dreamhackcs");
assert_eq!(stream.language, "en");
assert_eq!(t.check_in, Some(true));
assert_eq!(t.participant_nationality, Some(true));
assert_eq!(t.match_format, Some(MatchFormat::BestOf3));
}
}