mobileapp

package

Go to main page

Versions in this module

v1

v1.1.0

Jul 14, 2026

v1.0.0

Jul 13, 2026

Changes in this version

+ const MaxLenWebsiteURL

+ func RegisterExportResultsHandlers(r *gin.RouterGroup, store *state.Store, eng *engine.Engine)

+ func RegisterPublicLeagueHandlers(r *gin.RouterGroup, eng *engine.Engine)

+ func RegisterTimeHandlers(r *gin.RouterGroup)

type ScoringEngine

+ CheckKachinukiPrematureCompletion func(compID, matchID string, result *state.MatchResult) error

v0

v0.17.0

Jul 1, 2026

Changes in this version

+ const AdminPasswordHashEnv

+ const AnnouncementMaxBodyBytes

+ const BrandingMaxBodyBytes

+ const BrandingMaxFileBytes

+ const DefaultPerIPBurst

+ const DefaultPerIPRate

+ const MaxBulkCheckInIDs

+ const MaxFightingSpiritAwards

+ const MaxLenAwardsNote

+ const MaxLenChangeReason

+ const MaxLenContactLabel

+ const MaxLenContactValue

+ const MaxLenCorrectionReason

+ const MaxLenDisplayTime

+ const MaxLenInfoNotes

+ const MaxLenMatchID

+ const MaxLenPublicURL

+ const MaxLenRevSession

+ const MaxLenRulesURL

+ const MaxLenVenueAddress

+ const MaxLenVenueMapURL

+ const MaxTournamentContacts

+ const MaxTournamentDurationDays

+ const ResetMaxBodyBytes

+ const SponsorMaxBodyBytes

+ const SponsorMaxFileBytes

+ func IsSelfRunReportableDecision(decision string, decidedByHantei *bool) bool

+ func IsSelfRunReportableSubDecision(decision string, decidedByHantei bool, position int) bool

+ func RegisterAdminPasswordHandler(r *gin.RouterGroup, store *state.Store, ev ElevatedVerifier)

+ func RegisterBrandingHandlers(r *gin.RouterGroup, store *state.Store)

+ func RegisterLeagueTiebreakHandlers(r *gin.RouterGroup, eng LeagueTiebreakEngine, store LeagueTiebreakStore, ...)

+ func RegisterPrintHandlers(r *gin.RouterGroup, eng *engine.Engine)

+ func RegisterPublicBrandingHandlers(r *gin.RouterGroup, store *state.Store)

+ func RegisterPublicLeagueTiebreakHandlers(r *gin.RouterGroup, eng LeagueTiebreakEngine, store LeagueTiebreakStore)

+ func RegisterPublicRegistrationHandlers(r *gin.RouterGroup, store *state.Store, hub Broadcaster)

+ func RegisterPublicSponsorHandlers(r *gin.RouterGroup, store *state.Store)

+ func RegisterSponsorHandlers(r *gin.RouterGroup, store *state.Store)

+ func RegisterVersionHandlers(r *gin.RouterGroup)

+ func RequireElevatedPassword(ev ElevatedVerifier) gin.HandlerFunc

+ type APIRateLimiter struct

+ func NewAPIRateLimiter(globalRate float64, globalBurst int) *APIRateLimiter

+ func (rl *APIRateLimiter) Close()

+ func (rl *APIRateLimiter) Middleware() gin.HandlerFunc

type CompetitionStore

+ LoadBracket func(id string) (*state.Bracket, error)

+ LoadPoolMatches func(id string) ([]state.MatchResult, error)

type CompetitionTransactor

+ WithCourtExclusivityLock func(fn func() error) error

type DaihyosenEngine

+ RecordMatchResultWithIneligibilityTx func(tx state.StoreTx, compID, matchID string, result *state.MatchResult) (*domain.CompetitorStatus, error)

type DaihyosenStore

+ WithTransaction func(compID string, fn func(tx state.StoreTx) error) error

+ type ElevatedVerifier interface

+ Configured func() bool

+ GateActive func() bool

+ Mode func() string

+ Verify func(presented string) (bool, error)

+ func NewBcryptElevatedVerifier(hash string) (ElevatedVerifier, error)

+ func NewFileElevatedVerifier(store *state.Store) ElevatedVerifier

+ func NewLockedUnconfiguredElevatedVerifier() ElevatedVerifier

type EventType

+ const EventDrawDiscarded

+ const EventDrawGenerated

+ const EventLineupUpdated

+ const EventResyncRequired

type Hub

+ HeartbeatInterval time.Duration

+ type LeagueTiebreakEngine interface

+ GenerateLeagueTiebreakMatches func(compID string, tiedTeamNames []string) ([]state.MatchResult, error)

+ LeagueTiebreakCandidates func(compID string) ([]engine.TiedGroup, error)

+ MaybeAutoCompletePools func(compID string) (engine.AutoCompleteOutcome, error)

+ type LeagueTiebreakStore interface

+ LoadCompetition func(id string) (*state.Competition, error)

+ LoadPoolMatches func(id string) ([]state.MatchResult, error)

+ SavePoolMatches func(id string, matches []state.MatchResult) error

+ UpdateCompetitionChanged func(id string, ...) (bool, error)

+ WithTransaction func(compID string, fn func(tx state.StoreTx) error) error

type LineupRequest

+ ChangeReason string

+ Force bool

type ScoringEngine

+ CheckCrossCompCourtBusy func(compID, matchID string) error

type TeamLineupStore

+ DeleteTeamLineupForMatch func(compID, teamID, matchID string) error

+ LockTeamLineupForMatch func(compID, matchID string, lockedAt time.Time) error

+ type TournamentLoader interface

+ LoadTournament func() (*state.Tournament, error)

v0.16.3

May 24, 2026

v0.16.2

May 24, 2026

v0.16.1

May 24, 2026

v0.16.0

May 24, 2026

Changes in this version

+ const AutoCompleteErrorHeader

+ const AutoCompleteErrorValue

+ const DefaultHistorySize

+ const DefaultMaxBodyBytes

+ const DefaultMaxSSEClients

+ const MaxImportBodyBytes

+ const MaxLenCeremonyBlock

+ const MaxLenCheckInWindow

+ const MaxLenCompetitionDate

+ const MaxLenCompetitionName

+ const MaxLenCompetitionNumberPrefix

+ const MaxLenCompetitionStartTime

+ const MaxLenDecisionReason

+ const MaxLenEligibilityReason

+ const MaxLenEntityID

+ const MaxLenMatchScheduledAt

+ const MaxLenMatchSide

+ const MaxLenOriginatorID

+ const MaxLenPlayerDisplayName

+ const MaxLenPlayerDojo

+ const MaxLenPlayerMetadata

+ const MaxLenPlayerName

+ const MaxLenSeedAssignmentName

+ const MaxLenTournamentDate

+ const MaxLenTournamentName

+ const MaxLenTournamentPassword

+ const MaxLenTournamentVenue

+ const MaxPlayerMetadataItems

+ func AuthMiddleware(verifier PasswordVerifier, store *state.Store) gin.HandlerFunc

+ func MaxBodyBytes(n int64) gin.HandlerFunc

+ func RegisterAnnouncementHandlers(r *gin.RouterGroup, store *state.Store, hub *Hub)

+ func RegisterAuthConfigHandlers(r *gin.RouterGroup, verifier PasswordVerifier)

+ func RegisterCompetitionHandlers(r *gin.RouterGroup, store *state.Store, eng *engine.Engine, hub *Hub)

+ func RegisterDaihyosenHandlers(r *gin.RouterGroup, eng DaihyosenEngine, store DaihyosenStore, hub Broadcaster)

+ func RegisterDecisionHandlers(r *gin.RouterGroup, eng ScoringEngine, store CompetitionStore, ...)

+ func RegisterDisplayHandlers(r *gin.RouterGroup, store *state.Store)

+ func RegisterEligibilityHandlers(r *gin.RouterGroup, store CompetitorStatusStore, hub Broadcaster)

+ func RegisterImportHandlers(r *gin.RouterGroup, store *state.Store, hub *Hub)

+ func RegisterLineupHandlers(r *gin.RouterGroup, store TeamLineupStore, comps CompetitionStore, ...)

+ func RegisterMatchHandlers(r *gin.RouterGroup, eng *engine.Engine, store CompetitionStore, ...)

+ func RegisterParticipantHandlers(r *gin.RouterGroup, store *state.Store, hub Broadcaster)

+ func RegisterPublicAnnouncementHandlers(r *gin.RouterGroup, store *state.Store)

+ func RegisterPublicEligibilityHandlers(r *gin.RouterGroup, store CompetitorStatusStore)

+ func RegisterPublicLineupHandlers(r *gin.RouterGroup, store TeamLineupStore)

+ func RegisterPublicSwissHandlers(r *gin.RouterGroup, store *state.Store, eng *engine.Engine)

+ func RegisterReinstateHandler(r *gin.RouterGroup, eng EligibilityEngine, hub Broadcaster)

+ func RegisterResetHandlers(r *gin.RouterGroup, store *state.Store, verifier PasswordVerifier, hub *Hub)

+ func RegisterScheduleHandlers(r *gin.RouterGroup)

+ func RegisterSwissHandlers(r *gin.RouterGroup, store *state.Store, eng *engine.Engine, hub *Hub)

+ func RegisterTournamentHandlers(r *gin.RouterGroup, store *state.Store, hub *Hub, verifier PasswordVerifier)

+ func RegisterViewerHandlers(r *gin.RouterGroup, store *state.Store, eng *engine.Engine)

+ type Broadcaster interface

+ Broadcast func(eventType EventType, data any)

+ type CompetitionStore interface

+ LoadCompetition func(id string) (*state.Competition, error)

+ type CompetitionTransactor interface

+ WithTransaction func(compID string, fn func(tx state.StoreTx) error) error

+ type CompetitorStatusRequest struct

+ Eligible bool

+ MatchID string

+ PlayerID string

+ Reason string

+ func (r *CompetitorStatusRequest) Validate() error

+ type CompetitorStatusStore interface

+ LoadCompetitorStatus func(compID string) (map[string]domain.CompetitorStatus, error)

+ SetCompetitorStatus func(compID string, status domain.CompetitorStatus) error

+ type DaihyosenEngine interface

+ AddDaihyosen func(compID, matchID string, sideA, sideB engine.TeamSummary, isPool bool, ...) (*state.SubMatchResult, error)

+ MaybeAutoCompletePools func(compID string) (engine.AutoCompleteOutcome, error)

+ RecordMatchResultWithIneligibility func(compID, matchID string, result *state.MatchResult) (*domain.CompetitorStatus, error)

+ type DaihyosenStore interface

+ LoadBracket func(compID string) (*state.Bracket, error)

+ LoadCompetition func(compID string) (*state.Competition, error)

+ LoadParticipants func(compID string, withZekkenName bool) ([]domain.Player, error)

+ LoadPoolMatches func(compID string) ([]state.MatchResult, error)

+ type DecisionRequest struct

+ Decision string

+ DecisionBy string

+ DecisionReason string

+ Encho *state.EnchoMetadata

+ Force bool

+ func (r *DecisionRequest) Validate() error

+ type EligibilityEngine interface

+ ReinstateCompetitor func(compID, playerID string) (*domain.CompetitorStatus, error)

+ type EventType string

+ const EventAnnouncement

+ const EventCompetitionCompleted

+ const EventCompetitionStarted

+ const EventCompetitorStatusUpdated

+ const EventMatchUpdated

+ const EventParticipantsUpdated

+ const EventPasswordReset

+ const EventScheduleUpdated

+ const EventSwissRoundGenerated

+ const EventTournamentUpdated

+ type Hub struct

+ HistorySize int

+ MaxClients int

+ func NewHub() *Hub

+ func NewHubWithHistory(historySize int) *Hub

+ func NewHubWithLimits(historySize, maxClients int) *Hub

+ func NewRouter(store *state.Store, eng *engine.Engine, res *resources.Resources, ...) (*gin.Engine, *Hub)

+ func NewRouterWithHub(store *state.Store, eng *engine.Engine, res *resources.Resources, ...) (*gin.Engine, *Hub)

+ func (h *Hub) Broadcast(eventType EventType, data any)

+ func (h *Hub) Close()

+ func (h *Hub) HandleEvents() gin.HandlerFunc

+ func (h *Hub) Subscribe() chan string

+ func (h *Hub) Unsubscribe(ch chan string)

+ type ImportManifest struct

+ Competitions []ImportManifestComp

+ type ImportManifestComp struct

+ Courts []string

+ Date string

+ Format string

+ ID string

+ Kind string

+ Mirror bool

+ Name string

+ NumberPrefix string

+ Participants string

+ PoolSize int

+ PoolSizeMode string

+ PoolWinners int

+ RoundRobin bool

+ Seeds string

+ StartTime string

+ SwissRounds int

+ TeamSize int

+ WithZekkenName bool

+ type ImportResult struct

+ Error string

+ ID string

+ Name string

+ ParticipantCount int

+ SeedCount int

+ type LineupRequest struct

+ Positions map[domain.Position]string

+ type PasswordVerifier interface

+ AllowsFileBootstrap func() bool

+ EnforceEmptyStoredGuard func() bool

+ Mode func() string

+ RedactStoredPassword func() bool

+ ResetEnabled func() bool

+ Verify func(presented string) (bool, error)

+ func NewBcryptVerifier(hash string) (PasswordVerifier, error)

+ func NewFileVerifier(store *state.Store) PasswordVerifier

+ type SSEEvent struct

+ Data any

+ Seq int64

+ Type EventType

+ type ScoreRequest state.MatchResult

+ func (r *ScoreRequest) AsMatchResult() *state.MatchResult

+ func (r *ScoreRequest) Validate() error

+ type ScoringEngine interface

+ MaybeAdvanceKachinuki func(compID, matchID string) (bool, error)

+ MaybeAutoCompletePools func(compID string) (engine.AutoCompleteOutcome, error)

+ OverrideBracketWinner func(compID string, matchID string, winnerName string) error

+ RecordDecision func(compID, matchID, decision, decisionBy, decisionReason string, ...) (*state.MatchResult, *domain.CompetitorStatus, error)

+ RecordDecisionTx func(tx state.StoreTx, compID, matchID, decision, decisionBy, decisionReason string, ...) (*state.MatchResult, *domain.CompetitorStatus, error)

+ RecordMatchResult func(compID string, matchID string, result *state.MatchResult) error

+ RecordMatchResultWithIneligibility func(compID string, matchID string, result *state.MatchResult) (*domain.CompetitorStatus, error)

+ RecordMatchResultWithIneligibilityTx func(tx state.StoreTx, compID, matchID string, result *state.MatchResult) (*domain.CompetitorStatus, error)

+ StartMatchTx func(tx state.StoreTx, compID, matchID string) error

+ UpdateMatchCourt func(compID string, matchID string, newCourt string) error

+ UpdateMatchTime func(compID string, matchID string, scheduledAt string) error

+ type TeamLineupStore interface

+ DeleteTeamLineup func(compID, teamID string, round int) error

+ LoadTeamLineups func(compID string) (map[string]domain.TeamLineup, error)

+ LockTeamLineupsForRound func(compID string, round int, lockedAt time.Time) error

+ SetTeamLineup func(compID string, lineup domain.TeamLineup, teamSize int) error

+ type ValidationError struct

+ Field string

+ Message string

+ func (e *ValidationError) Error() string

+ type Validator interface

+ Validate func() error

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL