Struct toornament::Toornament

pub struct Toornament { /* fields omitted */ }

Main structure. Should be your point of start using the service. This struct covers all the toornament API.

Methods

impl Toornament

fn with_application<S: Into<String>>(
    api_token: S,
    client_id: S,
    client_secret: S
) -> Result<Toornament>

Creates new Toornament object with client credentials which is your user API_Token, application's client id and secret. You may obtain application's credentials here (You must be logged in to open the page). This method connects to the toornament service and if there is a error it returns the Error object and on success it returns Toornament object.

fn disciplines(&self, id: Option<DisciplineId>) -> Result<Disciplines>

Returns either a collection of disciplines if id is None or a disciplines with the detail of his features

fn tournaments(
    &self,
    id: Option<TournamentId>,
    with_streams: bool
) -> Result<Tournaments>

Returns a collection of public tournaments filtered and sorted by the given query parameters. A maximum of 20 tournaments will be returned. Only public tournaments are visible. if id is None or a detailed information about one tournament. The tournament must be public.

fn edit_tournament(&self, tournament: Tournament) -> Result<Tournament>

Updates some of the editable information on a tournament. if tournament.id is set otherwise creates a tournament.

fn delete_tournament(&self, id: TournamentId) -> Result<()>

Deletes a tournament, its participants and all its matches.

fn my_tournaments(&self) -> Result<Tournaments>

Returns the private and public tournaments on which the authenticated user has access. The result is filtered, sorted and paginated by the given query parameters. A maximum of 50 tournaments is returned (per page).

fn matches(
    &self,
    id: TournamentId,
    match_id: Option<MatchId>,
    with_games: bool
) -> Result<Matches>

Returns a collection of matches from one tournament. The collection may be filtered and sorted by optional query parameters. The tournament must be public to have access to its matches, meaning the tournament organizer has published it.

fn matches_by_discipline(
    &self,
    id: DisciplineId,
    filter: Option<MatchFilter>
) -> Result<Matches>

Retrieve a collection of matches from a specific discipline, filtered and sorted by the given query parameters. It might be a list of matches from different tournaments, but only from public tournaments. The matches are returned by 20.

fn update_match(
    &self,
    id: TournamentId,
    match_id: MatchId,
    updated_match: Match
) -> Result<Match>

If you need to make changes on your match data, you are able to do so by patching one or several fields of your match.

fn match_result(
    &self,
    id: TournamentId,
    match_id: MatchId
) -> Result<MatchResult>

Returns detailed result about one match.

fn set_match_result(
    &self,
    id: TournamentId,
    match_id: MatchId,
    result: MatchResult
) -> Result<MatchResult>

Update or create detailed result about one match.

fn match_games(
    &self,
    id: TournamentId,
    match_id: MatchId,
    with_stats: bool
) -> Result<Games>

Returns a collection of games from one match.

fn match_game(
    &self,
    id: TournamentId,
    match_id: MatchId,
    game_number: GameNumber,
    with_stats: bool
) -> Result<Game>

Returns detailed information about one game.

fn update_match_game(
    &self,
    id: TournamentId,
    match_id: MatchId,
    game_number: GameNumber,
    game: Game
) -> Result<Game>

If you need to make changes on your game data, you are able to do so by patching one or several fields of your game.

fn match_game_result(
    &self,
    id: TournamentId,
    match_id: MatchId,
    game_number: GameNumber
) -> Result<MatchResult>

Returns detailed result about one specific game.

fn update_match_game_result(
    &self,
    id: TournamentId,
    match_id: MatchId,
    game_number: GameNumber,
    result: MatchResult,
    update_match: bool
) -> Result<MatchResult>

Updates or creates detailed result about one game.

fn tournament_participants(
    &self,
    id: TournamentId,
    filter: TournamentParticipantsFilter
) -> Result<Participants>

Returns a collection of participants from one tournament. The tournament must be public to have access to its participants, meaning the tournament organizer has published it. The participants are returned by 256.

fn create_tournament_participant(
    &self,
    id: TournamentId,
    participant: Participant
) -> Result<Participant>

Create a participant in a tournament.

fn update_tournament_participants(
    &self,
    id: TournamentId,
    participants: Participants
) -> Result<Participants>

Create a list of participants in a tournament. If any participant already exists he will be erased.

fn get_tournament_participant(
    &self,
    id: TournamentId,
    participant_id: ParticipantId
) -> Result<Participant>

Returns detailed information about one participant.

fn update_tournament_participant(
    &self,
    id: TournamentId,
    participant_id: ParticipantId,
    participant: Participant
) -> Result<Participant>

Update some of the editable information on a participant.

fn delete_tournament_participant(
    &self,
    id: TournamentId,
    participant_id: ParticipantId
) -> Result<()>

Deletes one participant.

fn tournament_permissions(&self, id: TournamentId) -> Result<Permissions>

Returns a collection of permission from one tournament.

fn create_tournament_permission(
    &self,
    id: TournamentId,
    permission: Permission
) -> Result<Permission>

Create a permission for a user on a tournament.

fn tournament_permission(
    &self,
    id: TournamentId,
    permission_id: PermissionId
) -> Result<Permission>

Retrieves a permission of a tournament.

fn update_tournament_permission_attributes(
    &self,
    id: TournamentId,
    permission_id: PermissionId,
    attributes: PermissionAttributes
) -> Result<Permission>

Update rights of a permission.

fn delete_tournament_permission(
    &self,
    id: TournamentId,
    permission_id: PermissionId
) -> Result<()>

Delete a user permission of a tournament.

fn tournament_stages(&self, id: TournamentId) -> Result<Stages>

Returns a collection of stages from one tournament. The tournament must be public to have access to its stages, meaning the tournament organizer must publish it.

fn tournament_videos(
    &self,
    id: TournamentId,
    filter: TournamentVideosFilter
) -> Result<Videos>

Returns a collection of videos from one tournament. The collection may be filtered and sorted by optional query parameters. The tournament must be public to have access to its videos, meaning the tournament organizer has published it. The videos are returned by 20.

Trait Implementations

impl Debug for Toornament

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.