golio: github.com/KnutZuidema/golio/api Index | Files

package api

import "github.com/KnutZuidema/golio/api"

Package api contains the implementation for all Riot API and Data Dragon endpoints, as well as constant values used throughout the API and error values for known error return codes from the Riot API

Index

Package Files

constants.go data_dragon.go docs.go doer.go error.go riot_api.go

Constants

❖
const (
    LanguageCodeCzechRepublic            languageCode = "cs_CZ"
    LanguageCodeGreece                                = "el_GR"
    LanguageCodePoland                                = "pl_PL"
    LanguageCodeRomania                               = "ro_RO"
    LanguageCodeHungary                               = "hu_HU"
    LanguageCodeUnitedKingdom                         = "en_GB"
    LanguageCodeGermany                               = "de_DE"
    LanguageCodeSpain                                 = "es_ES"
    LanguageCodeItaly                                 = "it_IT"
    LanguageCodeFrance                                = "fr_FR"
    LanguageCodeJapan                                 = "ja_JP"
    LanguageCodeKorea                                 = "ko_KR"
    LanguageCodeMexico                                = "es_MX"
    LanguageCodeArgentina                             = "es_AR"
    LanguageCodeBrazil                                = "pt_BR"
    LanguageCodeUnitedStates                          = "en_US"
    LanguageCodeAustralia                             = "en_AU"
    LanguageCodeRussia                                = "ru_RU"
    LanguageCodeTurkey                                = "tr_TR"
    LanguageCodeMalaysia                              = "ms_MY"
    LanguageCodeRepublicOfThePhilippines              = "en_PH"
    LanguageCodeSingapore                             = "en_SG"
    LanguageCodeThailand                              = "th_TH"
    LanguageCodeVietNam                               = "vn_VN"
    LanguageCodeIndonesia                             = "id_ID"
    LanguageCodeMalaysiaChinese                       = "zh_MY"
    LanguageCodeChina                                 = "zh_CN"
    LanguageCodeTaiwan                                = "zh_TW"
)

All possible language codes

❖
const (
    QueueRankedSolo            queue = "RANKED_SOLO_5x5"
    QueueRankedFlex                  = "RANKED_FLEX_SR"
    QueueRankedTwistedTreeline       = "RANKED_FLEX_TT"
)

All possible queues

❖
const (
    TierIron     tier = "IRON"
    TierBronze        = "BRONZE"
    TierSilver        = "SILVER"
    TierGold          = "GOLD"
    TierPlatinum      = "PLATINUM"
    TierDiamond       = "DIAMOND"
)

All possible Tiers

❖
const (
    DivisionOne   division = "I"
    DivisionTwo            = "II"
    DivisionThree          = "III"
    DivisionFour           = "IV"
)

All possible divisions

❖
const (
    RegionBrasil            Region = "br1"
    RegionEuropeNorthEast          = "eun1"
    RegionEuropeWest               = "euw1"
    RegionJapan                    = "jp1"
    RegionKorea                    = "kr"
    RegionLatinAmericaNorth        = "la1"
    RegionLatinAmericaSouth        = "la2"
    RegionNorthAmerica             = "na1"
    RegionOceania                  = "oc1"
    RegionTurkey                   = "tr1"
    RegionRussia                   = "ru"
    RegionPBE                      = "pbe1"
)

All existing regions

Variables

❖
var (
    // LanguageCodes is a list of all possible language codes
    LanguageCodes = []languageCode{
        LanguageCodeCzechRepublic,
        LanguageCodeGreece,
        LanguageCodePoland,
        LanguageCodeRomania,
        LanguageCodeHungary,
        LanguageCodeUnitedKingdom,
        LanguageCodeGermany,
        LanguageCodeSpain,
        LanguageCodeItaly,
        LanguageCodeFrance,
        LanguageCodeJapan,
        LanguageCodeKorea,
        LanguageCodeMexico,
        LanguageCodeArgentina,
        LanguageCodeBrazil,
        LanguageCodeUnitedStates,
        LanguageCodeAustralia,
        LanguageCodeRussia,
        LanguageCodeTurkey,
        LanguageCodeMalaysia,
        LanguageCodeRepublicOfThePhilippines,
        LanguageCodeSingapore,
        LanguageCodeThailand,
        LanguageCodeVietNam,
        LanguageCodeIndonesia,
        LanguageCodeMalaysiaChinese,
        LanguageCodeChina,
        LanguageCodeTaiwan,
    }

    // Queues is a list of all available queue types
    Queues = []queue{
        QueueRankedSolo,
        QueueRankedFlex,
        QueueRankedTwistedTreeline,
    }

    // Tiers is a list of all available tiers
    Tiers = []tier{
        TierIron,
        TierBronze,
        TierSilver,
        TierGold,
        TierPlatinum,
        TierDiamond,
    }

    // Divisions is a list of all available divisions
    Divisions = []division{
        DivisionOne,
        DivisionTwo,
        DivisionThree,
        DivisionFour,
    }

    // Regions is a list of all available regions
    Regions = []Region{
        RegionBrasil,
        RegionEuropeNorthEast,
        RegionEuropeWest,
        RegionJapan,
        RegionKorea,
        RegionLatinAmericaNorth,
        RegionLatinAmericaSouth,
        RegionNorthAmerica,
        RegionOceania,
        RegionTurkey,
        RegionRussia,
        RegionPBE,
    }
)
❖
var (
    ErrBadRequest = Error{
        Message:    "bad request",
        StatusCode: http.StatusBadRequest,
    }
    ErrUnauthorized = Error{
        Message:    "unauthorized",
        StatusCode: http.StatusUnauthorized,
    }
    ErrForbidden = Error{
        Message:    "forbidden",
        StatusCode: http.StatusForbidden,
    }
    ErrNotFound = Error{
        Message:    "not found",
        StatusCode: http.StatusNotFound,
    }
    ErrMethodNotAllowed = Error{
        Message:    "method not allowed",
        StatusCode: http.StatusMethodNotAllowed,
    }
    ErrUnsupportedMediaType = Error{
        Message:    "unsupported media type",
        StatusCode: http.StatusUnsupportedMediaType,
    }
    ErrRateLimitExceeded = Error{
        Message:    "rate limit exceeded",
        StatusCode: http.StatusTooManyRequests,
    }
    ErrInternalServerError = Error{
        Message:    "internal server error",
        StatusCode: http.StatusInternalServerError,
    }
    ErrBadGateway = Error{
        Message:    "bad gateway",
        StatusCode: http.StatusBadGateway,
    }
    ErrServiceUnavailable = Error{
        Message:    "service unavailable",
        StatusCode: http.StatusServiceUnavailable,
    }
    ErrGatewayTimeout = Error{
        Message:    "gateway timeout",
        StatusCode: http.StatusGatewayTimeout,
    }
    StatusToError = map[int]Error{
        http.StatusBadRequest:           ErrBadRequest,
        http.StatusUnauthorized:         ErrUnauthorized,
        http.StatusForbidden:            ErrForbidden,
        http.StatusNotFound:             ErrNotFound,
        http.StatusMethodNotAllowed:     ErrMethodNotAllowed,
        http.StatusUnsupportedMediaType: ErrUnsupportedMediaType,
        http.StatusTooManyRequests:      ErrRateLimitExceeded,
        http.StatusInternalServerError:  ErrInternalServerError,
        http.StatusBadGateway:           ErrBadGateway,
        http.StatusServiceUnavailable:   ErrServiceUnavailable,
        http.StatusGatewayTimeout:       ErrGatewayTimeout,
    }
)

All regularly returned errors by the Riot API

type DataDragonClient Uses

❖
type DataDragonClient struct {
    Version  string
    Language languageCode
    // contains filtered or unexported fields
}

DataDragonClient provides access to all data provided by the Data Dragon service

func NewDataDragonClient Uses

❖
func NewDataDragonClient(client Doer, region Region, logger log.FieldLogger) *DataDragonClient

NewDataDragonClient returns a new client for the Data Dragon service.

func (DataDragonClient) GetChampion Uses

❖
func (c DataDragonClient) GetChampion(name string) (*model.ChampionDataExtended, error)

GetChampion returns information about the champion with the given name

func (DataDragonClient) GetChampions Uses

❖
func (c DataDragonClient) GetChampions() (map[string]model.ChampionData, error)

GetChampions returns all existing champions

func (DataDragonClient) GetItems Uses

❖
func (c DataDragonClient) GetItems() (map[string]model.Item, error)

GetItems returns all existing items

func (DataDragonClient) GetMasteries Uses

❖
func (c DataDragonClient) GetMasteries() (map[string]model.Mastery, error)

GetMasteries returns all existing masteries. Masteries were removed in patch 7.23.1. If any version higher than that is specified the last available version will be used instead.

func (DataDragonClient) GetProfileIcons Uses

❖
func (c DataDragonClient) GetProfileIcons() (map[string]model.ProfileIcon, error)

GetProfileIcons returns all existing profile icons

func (DataDragonClient) GetSummonerSpells Uses

❖
func (c DataDragonClient) GetSummonerSpells() (map[string]model.SummonerSpell, error)

GetSummonerSpells returns all existing summoner spells

type Doer Uses

❖
type Doer interface {
    // Do processes an HTTP request and returns the response
    Do(r *http.Request) (*http.Response, error)
}

Doer is an interface for any client that can process an HTTP request and return a response. This will most commonly be a simple HTTP client.

type Error Uses

❖
type Error struct {
    Message    string
    StatusCode int
}

Error is a custom error type used by the API to signal http error responses

func (Error) Error Uses

❖
func (e Error) Error() string

type MatchStreamValue Uses

❖
type MatchStreamValue struct {
    *model.MatchReference
    Error error
}

MatchStreamValue value returned by GetMatchesByAccountStream, containing either a reference to a match or an error

type Region Uses

❖
type Region string

Region represents a server region

type RiotAPIClient Uses

❖
type RiotAPIClient struct {
    Region Region
    // contains filtered or unexported fields
}

RiotAPIClient provides access to all Riot API endpoints

func NewRiotAPIClient Uses

❖
func NewRiotAPIClient(region Region, apiKey string, client Doer, logger log.FieldLogger) *RiotAPIClient

NewRiotAPIClient returns a new api client for the Riot API

func (RiotAPIClient) CreateTournament Uses

❖
func (c RiotAPIClient) CreateTournament(parameters *model.TournamentRegistrationParameters, useStub bool) (int, error)

CreateTournament creates a tournament and returns the ID. For more information about the parameters see the documentation for TournamentRegistrationParameters. Set the useStub flag to true to use the stub endpoints for mocking an implementation

func (RiotAPIClient) CreateTournamentCodes Uses

❖
func (c RiotAPIClient) CreateTournamentCodes(tournamentID, count int, parameters *model.TournamentCodeParameters,
    useStub bool) ([]string, error)

CreateTournamentCodes creates a specified amount of codes for a tournament. For more information about the parameters see the documentation for TournamentCodeParameters. Set the useStub flag to true to use the stub endpoints for mocking an implementation

func (RiotAPIClient) CreateTournamentProvider Uses

❖
func (c RiotAPIClient) CreateTournamentProvider(parameters *model.ProviderRegistrationParameters,
    useStub bool) (int, error)

CreateTournamentProvider creates a tournament provider and returns the ID. For more information about the parameters see the documentation for ProviderRegistrationParameters. Set the useStub flag to true to use the stub endpoints for mocking an implementation

func (RiotAPIClient) GetChallengerLeague Uses

❖
func (c RiotAPIClient) GetChallengerLeague(queue queue) (*model.LeagueList, error)

GetChallengerLeague returns the current Challenger league for the Region

func (RiotAPIClient) GetChampionMasteries Uses

❖
func (c RiotAPIClient) GetChampionMasteries(summonerID string) ([]*model.ChampionMastery, error)

GetChampionMasteries returns information about masteries for the summoner with the given ID

func (RiotAPIClient) GetChampionMastery Uses

❖
func (c RiotAPIClient) GetChampionMastery(summonerID, championID string) (*model.ChampionMastery, error)

GetChampionMastery returns information about the mastery of the champion with the given ID the summoner with the given ID has

func (RiotAPIClient) GetChampionMasteryTotalScore Uses

❖
func (c RiotAPIClient) GetChampionMasteryTotalScore(summonerID string) (int, error)

GetChampionMasteryTotalScore returns the accumulated mastery score of all champions played by the summoner with the given ID

func (RiotAPIClient) GetCurrentGame Uses

❖
func (c RiotAPIClient) GetCurrentGame(summonerID string) (*model.CurrentGameInfo, error)

GetCurrentGame returns a currently running game for a summoner

func (RiotAPIClient) GetFeaturedGames Uses

❖
func (c RiotAPIClient) GetFeaturedGames() (*model.FeaturedGames, error)

GetFeaturedGames returns the currently featured games

func (RiotAPIClient) GetFreeChampionRotation Uses

❖
func (c RiotAPIClient) GetFreeChampionRotation() (*model.ChampionInfo, error)

GetFreeChampionRotation returns information about the current free champion rotation

func (RiotAPIClient) GetGrandmasterLeague Uses

❖
func (c RiotAPIClient) GetGrandmasterLeague(queue queue) (*model.LeagueList, error)

GetGrandmasterLeague returns the current Grandmaster league for the Region

func (RiotAPIClient) GetLeague Uses

❖
func (c RiotAPIClient) GetLeague(leagueID string) (*model.LeagueList, error)

GetLeague returns a ranked league with the specified ID

func (RiotAPIClient) GetLeagues Uses

❖
func (c RiotAPIClient) GetLeagues(queue queue, tier tier, division division) ([]*model.LeagueEntry, error)

GetLeagues returns all players with a a league specified by its queue, tier and division

func (RiotAPIClient) GetLeaguesBySummoner Uses

❖
func (c RiotAPIClient) GetLeaguesBySummoner(summonerID string) ([]*model.LeagueEntry, error)

GetLeaguesBySummoner returns all leagues a summoner with the given ID is in

func (RiotAPIClient) GetLobbyEvents Uses

❖
func (c RiotAPIClient) GetLobbyEvents(code string, useStub bool) (*model.LobbyEventList, error)

GetLobbyEvents returns the lobby events for a lobby specified by the tournament code Set the useStub flag to true to use the stub endpoints for mocking an implementation

func (RiotAPIClient) GetMasterLeague Uses

❖
func (c RiotAPIClient) GetMasterLeague(queue queue) (*model.LeagueList, error)

GetMasterLeague returns the current Master league for the Region

func (RiotAPIClient) GetMatch Uses

❖
func (c RiotAPIClient) GetMatch(id int) (*model.Match, error)

GetMatch returns a match specified by its ID

func (RiotAPIClient) GetMatchesByAccount Uses

❖
func (c RiotAPIClient) GetMatchesByAccount(accountID string, beginIndex, endIndex int) (*model.Matchlist, error)

GetMatchesByAccount returns a specified range of matches played on the account

func (RiotAPIClient) GetMatchesByAccountStream Uses

❖
func (c RiotAPIClient) GetMatchesByAccountStream(accountID string) <-chan MatchStreamValue

GetMatchesByAccountStream returns all matches played on this account as a stream, requesting new until there are no more new games

func (RiotAPIClient) GetStatus Uses

❖
func (c RiotAPIClient) GetStatus() (*model.Status, error)

GetStatus returns the current status of the services for the Region

func (RiotAPIClient) GetSummonerByAccount Uses

❖
func (c RiotAPIClient) GetSummonerByAccount(id string) (*model.Summoner, error)

GetSummonerByAccount returns the summoner with the given account ID

func (RiotAPIClient) GetSummonerByName Uses

❖
func (c RiotAPIClient) GetSummonerByName(name string) (*model.Summoner, error)

GetSummonerByName returns the summoner with the given summoner name

func (RiotAPIClient) GetSummonerByPUUID Uses

❖
func (c RiotAPIClient) GetSummonerByPUUID(puuid string) (*model.Summoner, error)

GetSummonerByPUUID returns the summoner with the given PUUID

func (RiotAPIClient) GetSummonerBySummonerID Uses

❖
func (c RiotAPIClient) GetSummonerBySummonerID(summonerID string) (*model.Summoner, error)

GetSummonerBySummonerID returns the summoner with the given ID

func (RiotAPIClient) GetThirdPartyCode Uses

❖
func (c RiotAPIClient) GetThirdPartyCode(id string) (string, error)

GetThirdPartyCode returns the third party code for the given summoner id

func (RiotAPIClient) GetTournament Uses

❖
func (c RiotAPIClient) GetTournament(code string) (*model.Tournament, error)

GetTournament returns an existing tournament

func (RiotAPIClient) UpdateTournament Uses

❖
func (c RiotAPIClient) UpdateTournament(code string, parameters model.TournamentUpdateParameters) error

UpdateTournament updates an existing tournament

Package api imports 10 packages (graph) and is imported by 1 packages. Updated 2019-07-21. Refresh now. Tools for package owners.