Package at.stefangeyer.challonge

Class Challonge

    • Method Detail

      • getTournaments

        public final java.util.List<Tournament> getTournaments​(TournamentQueryState state,
                                                       TournamentType type,
                                                       java.time.OffsetDateTime createdAfter,
                                                       java.time.OffsetDateTime createdBefore,
                                                       java.lang.String subdomain)
                                                throws DataAccessException
        Description copied from interface: TournamentService
        Retrieve a set of tournaments created with your account.
        Specified by:
        getTournaments in interface TournamentService
        Parameters:
        state - Only get tournaments with this state
        type - Only get tournaments with this type
        createdAfter - Get tournaments created after this date
        createdBefore - Get tournaments created before this date
        subdomain - Only get tournaments with this subdomain
        Returns:
        The filtered tournaments
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • getTournaments

        public final void getTournaments​(TournamentQueryState state,
                                 TournamentType type,
                                 java.time.OffsetDateTime createdAfter,
                                 java.time.OffsetDateTime createdBefore,
                                 java.lang.String subdomain,
                                 Callback<java.util.List<Tournament>> onSuccess,
                                 Callback<DataAccessException> onFailure)
        Description copied from interface: TournamentService
        Retrieve a set of tournaments created with your account.
        Specified by:
        getTournaments in interface TournamentService
        Parameters:
        state - Only get tournaments with this state
        type - Only get tournaments with this type
        createdAfter - Get tournaments created after this date
        createdBefore - Get tournaments created before this date
        subdomain - Only get tournaments with this subdomain
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • getTournament

        public final Tournament getTournament​(java.lang.String tournament,
                                      boolean includeParticipants,
                                      boolean includeMatches)
                               throws DataAccessException
        Description copied from interface: TournamentService
        Retrieve a single tournament record created with your account.
        Specified by:
        getTournament in interface TournamentService
        Parameters:
        tournament - Tournament ID (e.g. 10230) or URL (e.g. 'single_elim' for challonge.com/single_elim). If assigned to a subdomain, URL format must be :subdomain-:tournament_url (e.g. 'test-mytourney' for test.challonge.com/mytourney)
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        Returns:
        The matching tournament
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • getTournament

        public final void getTournament​(java.lang.String tournament,
                                boolean includeParticipants,
                                boolean includeMatches,
                                Callback<Tournament> onSuccess,
                                Callback<DataAccessException> onFailure)
        Description copied from interface: TournamentService
        Retrieve a single tournament record created with your account.
        Specified by:
        getTournament in interface TournamentService
        Parameters:
        tournament - Tournament ID (e.g. 10230) or URL (e.g. 'single_elim' for challonge.com/single_elim). If assigned to a subdomain, URL format must be :subdomain-:tournament_url (e.g. 'test-mytourney' for test.challonge.com/mytourney)
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • updateTournament

        public final void updateTournament​(Tournament tournament,
                                   TournamentQuery data,
                                   Callback<Tournament> onSuccess,
                                   Callback<DataAccessException> onFailure)
        Description copied from interface: TournamentService
        Update a tournament's attributes.
        Specified by:
        updateTournament in interface TournamentService
        Parameters:
        tournament - The tournament to update. Must contain tournament id
        data - An object with all the necessary information to update the tournament
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • deleteTournament

        public final void deleteTournament​(Tournament tournament,
                                   Callback<Tournament> onSuccess,
                                   Callback<DataAccessException> onFailure)
        Description copied from interface: TournamentService
        Deletes a tournament along with all its associated records. There is no undo, so use with care!
        Specified by:
        deleteTournament in interface TournamentService
        Parameters:
        tournament - The tournament to delete. Must contain tournament id
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • processCheckIns

        public final Tournament processCheckIns​(Tournament tournament,
                                        boolean includeParticipants,
                                        boolean includeMatches)
                                 throws DataAccessException
        Description copied from interface: TournamentService
        This should be invoked after a tournament's check-in window closes before the tournament is started.

        1. Marks participants who have not checked in as inactive. 2. Moves inactive participants to bottom seeds (ordered by original seed). 3. Transitions the tournament state from 'checking_in' to 'checked_in'

        NOTE: Checked in participants on the waiting list will be promoted if slots become available.

        Specified by:
        processCheckIns in interface TournamentService
        Parameters:
        tournament - The tournament to process check ins for. Must contain tournament id
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        Returns:
        The updated tournament
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • processCheckIns

        public final void processCheckIns​(Tournament tournament,
                                  boolean includeParticipants,
                                  boolean includeMatches,
                                  Callback<Tournament> onSuccess,
                                  Callback<DataAccessException> onFailure)
        Description copied from interface: TournamentService
        This should be invoked after a tournament's check-in window closes before the tournament is started.

        1. Marks participants who have not checked in as inactive. 2. Moves inactive participants to bottom seeds (ordered by original seed). 3. Transitions the tournament state from 'checking_in' to 'checked_in'

        NOTE: Checked in participants on the waiting list will be promoted if slots become available.

        Specified by:
        processCheckIns in interface TournamentService
        Parameters:
        tournament - The tournament to process check ins for. Must contain tournament id
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • abortCheckIn

        public final Tournament abortCheckIn​(Tournament tournament,
                                     boolean includeParticipants,
                                     boolean includeMatches)
                              throws DataAccessException
        Description copied from interface: TournamentService
        When your tournament is in a 'checking_in' or 'checked_in' state, there's no way to edit the tournament's start time (start_at) or check-in duration (check_in_duration). You must first abort check-in, then you may edit those attributes.

        1. Makes all participants active and clears their checked_in_at times. 2. Transitions the tournament state from 'checking_in' or 'checked_in' to 'pending'

        Specified by:
        abortCheckIn in interface TournamentService
        Parameters:
        tournament - The tournament to abort check in for. Must contain tournament id
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        Returns:
        The updated tournament
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • abortCheckIn

        public final void abortCheckIn​(Tournament tournament,
                               boolean includeParticipants,
                               boolean includeMatches,
                               Callback<Tournament> onSuccess,
                               Callback<DataAccessException> onFailure)
        Description copied from interface: TournamentService
        When your tournament is in a 'checking_in' or 'checked_in' state, there's no way to edit the tournament's start time (start_at) or check-in duration (check_in_duration). You must first abort check-in, then you may edit those attributes.

        1. Makes all participants active and clears their checked_in_at times. 2. Transitions the tournament state from 'checking_in' or 'checked_in' to 'pending'

        Specified by:
        abortCheckIn in interface TournamentService
        Parameters:
        tournament - The tournament to abort check in for. Must contain tournament id
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • startTournament

        public final Tournament startTournament​(Tournament tournament,
                                        boolean includeParticipants,
                                        boolean includeMatches)
                                 throws DataAccessException
        Description copied from interface: TournamentService
        Start a tournament, opening up first round matches for score reporting. The tournament must have at least 2 participants.
        Specified by:
        startTournament in interface TournamentService
        Parameters:
        tournament - The tournament to start. Must contain tournament id
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        Returns:
        The started tournament
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • startTournament

        public final void startTournament​(Tournament tournament,
                                  boolean includeParticipants,
                                  boolean includeMatches,
                                  Callback<Tournament> onSuccess,
                                  Callback<DataAccessException> onFailure)
        Description copied from interface: TournamentService
        Start a tournament, opening up first round matches for score reporting. The tournament must have at least 2 participants.
        Specified by:
        startTournament in interface TournamentService
        Parameters:
        tournament - The tournament to start. Must contain tournament id
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • finalizeTournament

        public final Tournament finalizeTournament​(Tournament tournament,
                                           boolean includeParticipants,
                                           boolean includeMatches)
                                    throws DataAccessException
        Description copied from interface: TournamentService
        Finalize a tournament that has had all match scores submitted, rendering its results permanent.
        Specified by:
        finalizeTournament in interface TournamentService
        Parameters:
        tournament - The tournament to finalize. Must contain tournament id
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        Returns:
        The finalized tournament
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • finalizeTournament

        public final void finalizeTournament​(Tournament tournament,
                                     boolean includeParticipants,
                                     boolean includeMatches,
                                     Callback<Tournament> onSuccess,
                                     Callback<DataAccessException> onFailure)
        Description copied from interface: TournamentService
        Finalize a tournament that has had all match scores submitted, rendering its results permanent.
        Specified by:
        finalizeTournament in interface TournamentService
        Parameters:
        tournament - The tournament to finalize. Must contain tournament id
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • resetTournament

        public final Tournament resetTournament​(Tournament tournament,
                                        boolean includeParticipants,
                                        boolean includeMatches)
                                 throws DataAccessException
        Description copied from interface: TournamentService
        Reset a tournament, clearing all of its scores and attachments. You can then add/remove/edit participants before starting the tournament again.
        Specified by:
        resetTournament in interface TournamentService
        Parameters:
        tournament - The tournament to reset. Must contain tournament id
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        Returns:
        The reset tournament
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • resetTournament

        public final void resetTournament​(Tournament tournament,
                                  boolean includeParticipants,
                                  boolean includeMatches,
                                  Callback<Tournament> onSuccess,
                                  Callback<DataAccessException> onFailure)
        Description copied from interface: TournamentService
        Reset a tournament, clearing all of its scores and attachments. You can then add/remove/edit participants before starting the tournament again.
        Specified by:
        resetTournament in interface TournamentService
        Parameters:
        tournament - The tournament to reset. Must contain tournament id
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • openTournamentForPredictions

        public final Tournament openTournamentForPredictions​(Tournament tournament,
                                                     boolean includeParticipants,
                                                     boolean includeMatches)
                                              throws DataAccessException
        Description copied from interface: TournamentService
        Sets the state of the tournament to start accepting predictions. Your tournament's 'prediction_method' attribute must be set to 1 (exponential scoring) or 2 (linear scoring) to use this option. Note: Once open for predictions, match records will be persisted, so participant additions and removals will no longer be permitted.
        Specified by:
        openTournamentForPredictions in interface TournamentService
        Parameters:
        tournament - The tournament to open predictions for. Must contain tournament id
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        Returns:
        The reset tournament
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • openTournamentForPredictions

        public final void openTournamentForPredictions​(Tournament tournament,
                                               boolean includeParticipants,
                                               boolean includeMatches,
                                               Callback<Tournament> onSuccess,
                                               Callback<DataAccessException> onFailure)
        Description copied from interface: TournamentService
        Sets the state of the tournament to start accepting predictions. Your tournament's 'prediction_method' attribute must be set to 1 (exponential scoring) or 2 (linear scoring) to use this option. Note: Once open for predictions, match records will be persisted, so participant additions and removals will no longer be permitted.
        Specified by:
        openTournamentForPredictions in interface TournamentService
        Parameters:
        tournament - The tournament to open predictions for. Must contain tournament id
        includeParticipants - Include a list of participants in the response
        includeMatches - Include a list of matches in the response
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • getParticipants

        public final void getParticipants​(Tournament tournament,
                                  Callback<java.util.List<Participant>> onSuccess,
                                  Callback<DataAccessException> onFailure)
        Description copied from interface: ParticipantService
        Retrieve a tournament's participant list.
        Specified by:
        getParticipants in interface ParticipantService
        Parameters:
        tournament - The tournament to get the participants from. Must contain tournament id
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • getParticipant

        public final Participant getParticipant​(Tournament tournament,
                                        long participantId,
                                        boolean includeMatches)
                                 throws DataAccessException
        Description copied from interface: ParticipantService
        Retrieve a single participant record for a tournament.
        Specified by:
        getParticipant in interface ParticipantService
        Parameters:
        tournament - The tournament to get the participant from. Must contain tournament id
        participantId - The participant's unique ID
        includeMatches - Includes an array of associated match records
        Returns:
        The requested participant
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • getParticipant

        public final void getParticipant​(Tournament tournament,
                                 long participantId,
                                 boolean includeMatches,
                                 Callback<Participant> onSuccess,
                                 Callback<DataAccessException> onFailure)
        Description copied from interface: ParticipantService
        Retrieve a single participant record for a tournament.
        Specified by:
        getParticipant in interface ParticipantService
        Parameters:
        tournament - The tournament to get the participant from. Must contain tournament id
        participantId - The participant's unique ID
        includeMatches - Includes an array of associated match records
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • bulkAddParticipants

        public final java.util.List<Participant> bulkAddParticipants​(Tournament tournament,
                                                             java.util.List<ParticipantQuery> data)
                                                      throws DataAccessException
        Description copied from interface: ParticipantService
        Bulk add participants to a tournament (up until it is started). If an invalid participant is detected, bulk participant creation will halt and any previously added participants (from this API request) will be rolled back.
        Specified by:
        bulkAddParticipants in interface ParticipantService
        Parameters:
        tournament - The tournament to add the participants to. Must contain tournament id
        data - The participant data
        Returns:
        The added participants
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • bulkAddParticipants

        public final void bulkAddParticipants​(Tournament tournament,
                                      java.util.List<ParticipantQuery> data,
                                      Callback<java.util.List<Participant>> onSuccess,
                                      Callback<DataAccessException> onFailure)
        Description copied from interface: ParticipantService
        Bulk add participants to a tournament (up until it is started). If an invalid participant is detected, bulk participant creation will halt and any previously added participants (from this API request) will be rolled back.
        Specified by:
        bulkAddParticipants in interface ParticipantService
        Parameters:
        tournament - The tournament to add the participants to. Must contain tournament id
        data - The participant data
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • checkInParticipant

        public final void checkInParticipant​(Participant participant,
                                     Callback<Participant> onSuccess,
                                     Callback<DataAccessException> onFailure)
        Description copied from interface: ParticipantService
        Checks a participant in, setting checked_in_at to the current time.
        Specified by:
        checkInParticipant in interface ParticipantService
        Parameters:
        participant - The participant to check in. Must contain the tournament id and the participant's id
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • undoCheckInParticipant

        public final void undoCheckInParticipant​(Participant participant,
                                         Callback<Participant> onSuccess,
                                         Callback<DataAccessException> onFailure)
        Description copied from interface: ParticipantService
        Marks a participant as having not checked in, setting checked_in_at to nil.
        Specified by:
        undoCheckInParticipant in interface ParticipantService
        Parameters:
        participant - The participant to check in. Must contain the tournament id and the participant's id
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • deleteParticipant

        public final Participant deleteParticipant​(Participant participant)
                                    throws DataAccessException
        Description copied from interface: ParticipantService
        If the tournament has not started, delete a participant, automatically filling in the abandoned seed number. If tournament is underway, mark a participant inactive, automatically forfeiting his/her remaining matches.
        Specified by:
        deleteParticipant in interface ParticipantService
        Parameters:
        participant - The participant to delete. Must contain the tournament id and the participant's id
        Returns:
        The deleted participant
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • deleteParticipant

        public final void deleteParticipant​(Participant participant,
                                    Callback<Participant> onSuccess,
                                    Callback<DataAccessException> onFailure)
        Description copied from interface: ParticipantService
        If the tournament has not started, delete a participant, automatically filling in the abandoned seed number. If tournament is underway, mark a participant inactive, automatically forfeiting his/her remaining matches.
        Specified by:
        deleteParticipant in interface ParticipantService
        Parameters:
        participant - The participant to delete. Must contain the tournament id and the participant's id
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • randomizeParticipants

        public final void randomizeParticipants​(Tournament tournament,
                                        Callback<java.util.List<Participant>> onSuccess,
                                        Callback<DataAccessException> onFailure)
        Description copied from interface: ParticipantService
        Randomize seeds among participants. Only applicable before a tournament has started.
        Specified by:
        randomizeParticipants in interface ParticipantService
        Parameters:
        tournament - The tournament to randomize. Must contain the tournament id
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • getMatches

        public final java.util.List<Match> getMatches​(Tournament tournament,
                                              Participant participant,
                                              MatchState state)
                                       throws DataAccessException
        Description copied from interface: MatchService
        Retrieve a tournament's match list.
        Specified by:
        getMatches in interface MatchService
        Parameters:
        tournament - The tournament to get the matches from. Must contain id or url with an optional subdomain
        participant - Only retrieve matches that include the specified participant. This parameter is optional. Provide null if you want to skip it.
        state - all (default), pending, open, complete. This parameter is optional. Provide null if you want to skip it.
        Returns:
        The tournament's matches
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • getMatches

        public final void getMatches​(Tournament tournament,
                             Participant participant,
                             MatchState state,
                             Callback<java.util.List<Match>> onSuccess,
                             Callback<DataAccessException> onFailure)
        Description copied from interface: MatchService
        Retrieve a tournament's match list.
        Specified by:
        getMatches in interface MatchService
        Parameters:
        tournament - The tournament to get the matches from. Must contain id or url with an optional subdomain
        participant - Only retrieve matches that include the specified participant. This parameter is optional. Provide null if you want to skip it.
        state - all (default), pending, open, complete. This parameter is optional. Provide null if you want to skip it.
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • getMatch

        public final Match getMatch​(Tournament tournament,
                            long matchId,
                            boolean includeAttachments)
                     throws DataAccessException
        Description copied from interface: MatchService
        Retrieve a single match record for a tournament.
        Specified by:
        getMatch in interface MatchService
        Parameters:
        tournament - The tournament to get the match from. Must contain tournament id
        matchId - The match's unique ID
        includeAttachments - Include an array of associated attachment records
        Returns:
        The requested match
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • getMatch

        public final void getMatch​(Tournament tournament,
                           long matchId,
                           boolean includeAttachments,
                           Callback<Match> onSuccess,
                           Callback<DataAccessException> onFailure)
        Description copied from interface: MatchService
        Retrieve a single match record for a tournament.
        Specified by:
        getMatch in interface MatchService
        Parameters:
        tournament - The tournament to get the match from. Must contain tournament id
        matchId - The match's unique ID
        includeAttachments - Include an array of associated attachment records
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • updateMatch

        public final Match updateMatch​(Match match,
                               MatchQuery data)
                        throws DataAccessException
        Description copied from interface: MatchService
        Update/submit the score(s) for a match.
        Specified by:
        updateMatch in interface MatchService
        Parameters:
        match - The match to update. Must contain the tournament- and match id
        data - The new match data
        Returns:
        The updated match
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • updateMatch

        public final void updateMatch​(Match match,
                              MatchQuery data,
                              Callback<Match> onSuccess,
                              Callback<DataAccessException> onFailure)
        Description copied from interface: MatchService
        Update/submit the score(s) for a match.
        Specified by:
        updateMatch in interface MatchService
        Parameters:
        match - The match to update. Must contain the tournament- and match id
        data - The new match data
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • reopenMatch

        public final Match reopenMatch​(Match match)
                        throws DataAccessException
        Description copied from interface: MatchService
        Reopens a match that was marked completed, automatically resetting matches that follow it.
        Specified by:
        reopenMatch in interface MatchService
        Parameters:
        match - The match to reopen. Must contain the tournament- and match id
        Returns:
        The reopened match
        Throws:
        DataAccessException - Exchange with the rest api or validation failed

      • reopenMatch

        public final void reopenMatch​(Match match,
                              Callback<Match> onSuccess,
                              Callback<DataAccessException> onFailure)
        Description copied from interface: MatchService
        Reopens a match that was marked completed, automatically resetting matches that follow it.
        Specified by:
        reopenMatch in interface MatchService
        Parameters:
        match - The match to reopen. Must contain the tournament- and match id
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • getAttachments

        public final void getAttachments​(Match match,
                                 Callback<java.util.List<Attachment>> onSuccess,
                                 Callback<DataAccessException> onFailure)
        Description copied from interface: AttachmentService
        Retrieve a match's attachments.
        Specified by:
        getAttachments in interface AttachmentService
        Parameters:
        match - The match to get the attachments from. Must contain the tournament- and match id
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • getAttachment

        public final Attachment getAttachment​(Match match,
                                      long attachmentId)
                               throws DataAccessException
        Description copied from interface: AttachmentService
        Retrieve a single match attachment record.
        Specified by:
        getAttachment in interface AttachmentService
        Parameters:
        match - The match to get the attachment from. Must contain the tournament- and match id
        attachmentId - The attachment's unique ID
        Returns:
        The requested attachment
        Throws:
        DataAccessException - Exchange with the rest api failed

      • getAttachment

        public final void getAttachment​(Match match,
                                long attachmentId,
                                Callback<Attachment> onSuccess,
                                Callback<DataAccessException> onFailure)
        Description copied from interface: AttachmentService
        Retrieve a single match attachment record.
        Specified by:
        getAttachment in interface AttachmentService
        Parameters:
        match - The match to get the attachment from. Must contain the tournament- and match id
        attachmentId - The attachment's unique ID
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • createAttachment

        public final Attachment createAttachment​(Match match,
                                         AttachmentQuery data)
                                  throws DataAccessException
        Description copied from interface: AttachmentService
        Add a file, link, or text attachment to a match. NOTE: The associated tournament's "accept_attachments" attribute must be true for this action to succeed.

        At least 1 of the 3 optional parameters (asset, url or description in the enumeration object) must be provided. Files up to 25MB are allowed for tournaments hosted by Challonge Premier subscribers.

        Specified by:
        createAttachment in interface AttachmentService
        Parameters:
        match - The match to create the attachment for. Must contain the tournament- and match id
        data - The attachment to create
        Returns:
        The created attachment
        Throws:
        DataAccessException - Exchange with the rest api failed

      • createAttachment

        public final void createAttachment​(Match match,
                                   AttachmentQuery data,
                                   Callback<Attachment> onSuccess,
                                   Callback<DataAccessException> onFailure)
        Description copied from interface: AttachmentService
        Add a file, link, or text attachment to a match. NOTE: The associated tournament's "accept_attachments" attribute must be true for this action to succeed.

        At least 1 of the 3 optional parameters (asset, url or description in the enumeration object) must be provided. Files up to 25MB are allowed for tournaments hosted by Challonge Premier subscribers.

        Specified by:
        createAttachment in interface AttachmentService
        Parameters:
        match - The match to create the attachment for. Must contain the tournament- and match id
        data - The attachment to create
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • updateAttachment

        public final Attachment updateAttachment​(Match match,
                                         Attachment attachment,
                                         AttachmentQuery data)
                                  throws DataAccessException
        Description copied from interface: AttachmentService
        Update the attributes of a match attachment.

        Sending the asset does neither work with base64 nor with a multipart-form-data request

        At least 1 of the 3 optional parameters (asset, url or description in the enumeration object) must be provided. Files up to 25MB are allowed for tournaments hosted by Challonge Premier subscribers.

        Specified by:
        updateAttachment in interface AttachmentService
        Parameters:
        match - The match to delete the attachment from. Must contain the tournament- and match id
        attachment - The attachment to update. Must contain the tournament- and match id
        data - The attachment to update
        Returns:
        The updated attachment
        Throws:
        DataAccessException - Exchange with the rest api failed

      • updateAttachment

        public final void updateAttachment​(Match match,
                                   Attachment attachment,
                                   AttachmentQuery data,
                                   Callback<Attachment> onSuccess,
                                   Callback<DataAccessException> onFailure)
        Description copied from interface: AttachmentService
        Update the attributes of a match attachment.

        Sending the asset does neither work with base64 nor with a multipart-form-data request

        At least 1 of the 3 optional parameters (asset, url or description in the enumeration object) must be provided. Files up to 25MB are allowed for tournaments hosted by Challonge Premier subscribers.

        Specified by:
        updateAttachment in interface AttachmentService
        Parameters:
        match - The match to delete the attachment from. Must contain the tournament- and match id
        attachment - The attachment to update. Must contain the tournament- and match id
        data - The attachment to update
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful

      • deleteAttachment

        public final void deleteAttachment​(Match match,
                                   Attachment attachment,
                                   Callback<Attachment> onSuccess,
                                   Callback<DataAccessException> onFailure)
        Description copied from interface: AttachmentService
        Delete a match attachment.
        Specified by:
        deleteAttachment in interface AttachmentService
        Parameters:
        match - The match to delete the attachment from. Must contain the tournament- and match id
        attachment - The attachment to delete. Must contain the tournament- and match id
        onSuccess - Called with result if call was successful
        onFailure - Called with exception if call was not successful