model

type Acl struct {
	// User key or Group key.
	Requestor *datastore.Key

	// The key of the protected resource.
	Resource *datastore.Key

	// The entity type of the resource key.
	ResourceKind string

	Permission Permission
}

type CollectiveGameStats struct {
	// contains filtered or unexported fields
}

type DistributedRateLimiter struct {
	Name   string
	Limits []RateLimit
}

type DistributedRateLimiterEntity struct {
	// Counts of the total number of requests accepted.
	AcceptCount int64

	// Internal buckets.
	Buckets []TokenBucket
}

type ErrNotAuthorized struct {
	Permission Permission
	Resource   *datastore.Key
}

type ErrRateLimitExceeded struct {
	RateLimit *DistributedRateLimiter
	Debug     error
}

type ErrorNoRiotApiKey struct{}

type Game struct {
	Region string
	RiotId int64

	// Fields below are populated from riot player stats.
	HasRiotData   bool
	StartDateTime time.Time
	MapId         int
	GameMode      string
	GameType      string
	SubType       string
	Players       []riot.PlayerDto
	Invalid       bool
}

type GameByTeam struct {
	GameKey  *datastore.Key
	TeamKey  *datastore.Key
	DateTime time.Time

	// Contains {riot.BlueTeamId, riot.PurpleTeamId} if that team contained at least 3
	// members of the team.
	RiotTeamIds []int
}

type GameByTime []*Game

type GameInfo struct {
	Game *Game

	// Non-empty when viewed in the context of a league.
	LeagueId string

	BlueTeam   *GameTeamInfo
	PurpleTeam *GameTeamInfo

	// Aliases for BlueTeam/PurpleTeam based on which side has more summoners that are players
	// of the team someone is inspecting in the application.
	ThisTeam  *GameTeamInfo
	OtherTeam *GameTeamInfo
	// contains filtered or unexported fields
}

type GamePlayerInfo struct {
	Player     *Player
	ChampionId int
}

type GamePlayerStatsInfo struct {
	Saved        bool
	NotAvailable bool
	IsOnAppTeam  bool
	Player       *Player
	Stats        *PlayerGameStats
}

type GameStats struct {
	// contains filtered or unexported fields
}

type GameTag struct {
	Game   *datastore.Key
	Tag    string
	Reason string
}

type GameTags struct {
	GameKey *datastore.Key
	Tag     string
}

type GameTeamInfo struct {
	IsBlueTeam   bool
	IsPurpleTeam bool
	Players      []*GamePlayerInfo
	PlayerStats  []*GamePlayerStatsInfo

	// stats
	IsWinner        bool
	ChampionsKilled int
	NumDeaths       int
	Assists         int
	GoldEarned      int
}

type Group struct {
	Name string
}

type GroupMembership struct {
	GroupKey *datastore.Key
	UserKey  *datastore.Key
	Owner    bool
}

type GroupRoot struct{}

type KeysOnlyOption bool

type League struct {
	// The name of the league. Not necessarily unique.
	Name string

	// The Riot server region for this league. Defaults to RegionNA.
	Region string

	// The datastore key for the User who owns this league.
	Owner *datastore.Key
}

type MatchResult struct {
	ScheduledMatch *datastore.Key
	Team           *datastore.Key
	Points         int
	ManualResult   bool
}

type Permission int

type Player struct {
	// The current summoner name for this player.
	Summoner string

	// This is the region for the given player.
	Region string

	// Summoner id as per Riot API.
	RiotId int64

	// This player's in game level.
	Level int

	LastUpdated time.Time
}

type PlayerCache struct {
	Region string
	// contains filtered or unexported fields
}

type PlayerGameStats struct {
	GameKey   *datastore.Key
	PlayerKey *datastore.Key

	// Stats for games that have expired out of recent player history on the Riot side
	// before we get around to looking for them may be lost forever. This field is set
	// to true if we know the game stats are no longer available and we don't have a
	// copy yet.
	NotAvailable bool

	// Set to true when we have captured the stats for this player and game already.
	Saved bool

	// The raw stats fetched from riot.
	RiotData riot.RawStatsDto
}

type PlayerScoring interface {
	Score(match *ScheduledMatch, player *Player, games []*GameInfo) Score
}

type PlayersBySummoner []*Player

type ProposedGroupMembership struct {
	GroupKey *datastore.Key
	UserKey  *datastore.Key
	Notes    string
}

type RateLimit struct {
	MaxEvents       int
	IntervalSeconds int
}

type RequestorAclCache struct {
	UserKey        *datastore.Key
	EncodedUserKey string
	Groups         map[string]*Group
	GroupKeys      map[string]*datastore.Key
	// contains filtered or unexported fields
}

type ResourceAclCache struct {
	ResourceKey             *datastore.Key
	EncodedResourceKey      string
	Permission              Permission
	AuthorizedRequestorKeys map[string]*datastore.Key
}

type RiotApiKey struct {
	Key string
}

type ScheduledMatch struct {
	// A brief "one-line description" of the match.
	// Example: "Summoner's Rift Draft (Best of 1)"
	Summary string

	// A more detailed description of the match.
	Description string

	// The primary tag used to group this with other matches.
	// Example: "Week 1"
	PrimaryTag string

	// The teams involved in the match.
	TeamKeys []*datastore.Key

	// The number of games in the match. Zero or less means "no limit".
	NumGames int

	// The official suggested date(time) of the match.
	OfficialDatetime time.Time

	// The earliest the match should be played. This is not enforced.
	DateEarliest time.Time

	// The latest the match should be played. This is not enforced.
	DateLatest time.Time
}

type Score struct {
	// The number of points earned.
	Points int
	// True if the score will not change if additional games are played.
	IsFinal bool
}

type SummonerData struct {
	Player   *Player
	Verified bool
	Token    string
}

type Team struct {
	Name string
}

type TeamInfo struct {
	Name string
	Id   string
	Uri  string
}

type TeamMembership struct {
	TeamKey   *datastore.Key
	PlayerKey *datastore.Key
}

type TeamScoring interface {
	Score(match *ScheduledMatch, games []*GameInfo) Score
}

type TeamScoringType int

type TokenBucket struct {
	Limit RateLimit

	// The number of tokens in the bucket at LastCheckTime.
	Tokens float64

	// Tracks the last time this token bucket was processed so that we can
	// optimize adding tokens to the bucket each update instead of every
	// Rate seconds. Time is in UTC.
	LastCheckTime time.Time
}

type UnverifiedSummoner struct {
	User       *datastore.Key
	Player     *datastore.Key
	Token      string
	CreateTime time.Time
}

type User struct {
	Email string

	// Empty if no verified summoner.
	DisplayName string
}

type UserGameTag struct {
	User *datastore.Key
	Game *datastore.Key
	Tag  string
}

type VerifiedSummoner struct {
	User   *datastore.Key
	Player *datastore.Key
}