327 lines
11 KiB
Go
327 lines
11 KiB
Go
package db
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/pkg/errors"
|
|
"github.com/uptrace/bun"
|
|
)
|
|
|
|
// PlayoffFormat represents the bracket format based on team count
|
|
type PlayoffFormat string
|
|
|
|
const (
|
|
// PlayoffFormat5to6 is for 5-6 teams: top 5 qualify, double-elimination style
|
|
PlayoffFormat5to6 PlayoffFormat = "5-6-teams"
|
|
// PlayoffFormat7to9 is for 7-9 teams: top 6 qualify, seeded bracket
|
|
PlayoffFormat7to9 PlayoffFormat = "7-9-teams"
|
|
// PlayoffFormat10to15 is for 10-15 teams: top 8 qualify
|
|
PlayoffFormat10to15 PlayoffFormat = "10-15-teams"
|
|
)
|
|
|
|
// PlayoffStatus represents the current state of a playoff bracket
|
|
type PlayoffStatus string
|
|
|
|
const (
|
|
PlayoffStatusUpcoming PlayoffStatus = "upcoming"
|
|
PlayoffStatusInProgress PlayoffStatus = "in_progress"
|
|
PlayoffStatusCompleted PlayoffStatus = "completed"
|
|
)
|
|
|
|
// SeriesStatus represents the current state of a playoff series
|
|
type SeriesStatus string
|
|
|
|
const (
|
|
SeriesStatusPending SeriesStatus = "pending"
|
|
SeriesStatusInProgress SeriesStatus = "in_progress"
|
|
SeriesStatusCompleted SeriesStatus = "completed"
|
|
SeriesStatusBye SeriesStatus = "bye"
|
|
)
|
|
|
|
// PlayoffBracket is the top-level container for a league's playoff bracket
|
|
type PlayoffBracket struct {
|
|
bun.BaseModel `bun:"table:playoff_brackets,alias:pb"`
|
|
|
|
ID int `bun:"id,pk,autoincrement"`
|
|
SeasonID int `bun:",notnull,unique:season_league"`
|
|
LeagueID int `bun:",notnull,unique:season_league"`
|
|
Format PlayoffFormat `bun:",notnull"`
|
|
Status PlayoffStatus `bun:",notnull,default:'upcoming'"`
|
|
CreatedAt int64 `bun:",notnull"`
|
|
UpdatedAt *int64 `bun:"updated_at"`
|
|
|
|
Season *Season `bun:"rel:belongs-to,join:season_id=id"`
|
|
League *League `bun:"rel:belongs-to,join:league_id=id"`
|
|
Series []*PlayoffSeries `bun:"rel:has-many,join:id=bracket_id"`
|
|
}
|
|
|
|
// PlayoffSeries represents a single matchup (potentially best-of-N) in the bracket
|
|
type PlayoffSeries struct {
|
|
bun.BaseModel `bun:"table:playoff_series,alias:ps"`
|
|
|
|
ID int `bun:"id,pk,autoincrement"`
|
|
BracketID int `bun:",notnull"`
|
|
SeriesNumber int `bun:",notnull"` // Display order within bracket
|
|
Round string `bun:",notnull"` // e.g. "qualifying_final", "semi_final", "grand_final"
|
|
Label string `bun:",notnull"` // Human-readable label e.g. "QF1", "SF2", "Grand Final"
|
|
Team1ID *int `bun:"team1_id"`
|
|
Team2ID *int `bun:"team2_id"`
|
|
Team1Seed *int `bun:"team1_seed"` // Original seeding position (1st, 2nd, etc.)
|
|
Team2Seed *int `bun:"team2_seed"` // Original seeding position
|
|
WinnerTeamID *int `bun:"winner_team_id"` // Set when series is decided
|
|
LoserTeamID *int `bun:"loser_team_id"` // Set when series is decided
|
|
MatchesToWin int `bun:",notnull,default:1"` // 1 = single match, 2 = Bo3, 3 = Bo5, etc.
|
|
Team1Wins int `bun:",notnull,default:0"` // Matches won by team1
|
|
Team2Wins int `bun:",notnull,default:0"` // Matches won by team2
|
|
Status SeriesStatus `bun:",notnull,default:'pending'"` // pending, in_progress, completed, bye
|
|
WinnerNextID *int `bun:"winner_next_series_id"` // Series the winner advances to
|
|
WinnerNextSlot *string `bun:"winner_next_slot"` // "team1" or "team2" in next series
|
|
LoserNextID *int `bun:"loser_next_series_id"` // Series the loser drops to (double-elim)
|
|
LoserNextSlot *string `bun:"loser_next_slot"` // "team1" or "team2" in loser's next series
|
|
CreatedAt int64 `bun:",notnull"`
|
|
|
|
Bracket *PlayoffBracket `bun:"rel:belongs-to,join:bracket_id=id"`
|
|
Team1 *Team `bun:"rel:belongs-to,join:team1_id=id"`
|
|
Team2 *Team `bun:"rel:belongs-to,join:team2_id=id"`
|
|
Winner *Team `bun:"rel:belongs-to,join:winner_team_id=id"`
|
|
Loser *Team `bun:"rel:belongs-to,join:loser_team_id=id"`
|
|
Matches []*PlayoffMatch `bun:"rel:has-many,join:id=series_id"`
|
|
}
|
|
|
|
// PlayoffMatch represents a single game within a series
|
|
type PlayoffMatch struct {
|
|
bun.BaseModel `bun:"table:playoff_matches,alias:pm"`
|
|
|
|
ID int `bun:"id,pk,autoincrement"`
|
|
SeriesID int `bun:",notnull"`
|
|
MatchNumber int `bun:",notnull"` // 1-indexed: game 1, game 2, etc.
|
|
HomeTeamID *int `bun:"home_team_id"`
|
|
AwayTeamID *int `bun:"away_team_id"`
|
|
FixtureID *int `bun:"fixture_id"` // Links to existing fixture system
|
|
Status string `bun:",notnull,default:'pending'"`
|
|
CreatedAt int64 `bun:",notnull"`
|
|
|
|
Series *PlayoffSeries `bun:"rel:belongs-to,join:series_id=id"`
|
|
Home *Team `bun:"rel:belongs-to,join:home_team_id=id"`
|
|
Away *Team `bun:"rel:belongs-to,join:away_team_id=id"`
|
|
Fixture *Fixture `bun:"rel:belongs-to,join:fixture_id=id"`
|
|
}
|
|
|
|
// NewPlayoffBracket creates a new playoff bracket for a season+league
|
|
func NewPlayoffBracket(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
seasonID, leagueID int,
|
|
format PlayoffFormat,
|
|
audit *AuditMeta,
|
|
) (*PlayoffBracket, error) {
|
|
bracket := &PlayoffBracket{
|
|
SeasonID: seasonID,
|
|
LeagueID: leagueID,
|
|
Format: format,
|
|
Status: PlayoffStatusUpcoming,
|
|
CreatedAt: time.Now().Unix(),
|
|
}
|
|
err := Insert(tx, bracket).WithAudit(audit, &AuditInfo{
|
|
Action: "playoffs.create_bracket",
|
|
ResourceType: "playoff_bracket",
|
|
ResourceID: nil,
|
|
Details: map[string]any{
|
|
"season_id": seasonID,
|
|
"league_id": leagueID,
|
|
"format": string(format),
|
|
},
|
|
}).Exec(ctx)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "Insert")
|
|
}
|
|
return bracket, nil
|
|
}
|
|
|
|
// GetPlayoffBracket retrieves a playoff bracket for a season+league with all series and teams
|
|
func GetPlayoffBracket(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
seasonID, leagueID int,
|
|
) (*PlayoffBracket, error) {
|
|
bracket := new(PlayoffBracket)
|
|
err := tx.NewSelect().
|
|
Model(bracket).
|
|
Where("pb.season_id = ?", seasonID).
|
|
Where("pb.league_id = ?", leagueID).
|
|
Relation("Season").
|
|
Relation("League").
|
|
Relation("Series", func(q *bun.SelectQuery) *bun.SelectQuery {
|
|
return q.Order("ps.series_number ASC")
|
|
}).
|
|
Relation("Series.Team1").
|
|
Relation("Series.Team2").
|
|
Relation("Series.Winner").
|
|
Relation("Series.Loser").
|
|
Relation("Series.Matches", func(q *bun.SelectQuery) *bun.SelectQuery {
|
|
return q.Order("pm.match_number ASC")
|
|
}).
|
|
Scan(ctx)
|
|
if err != nil {
|
|
if err.Error() == "sql: no rows in result set" {
|
|
return nil, nil
|
|
}
|
|
return nil, errors.Wrap(err, "tx.NewSelect")
|
|
}
|
|
return bracket, nil
|
|
}
|
|
|
|
// GetPlayoffBracketByID retrieves a playoff bracket by ID with all series
|
|
func GetPlayoffBracketByID(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
bracketID int,
|
|
) (*PlayoffBracket, error) {
|
|
return GetByID[PlayoffBracket](tx, bracketID).
|
|
Relation("Season").
|
|
Relation("League").
|
|
Relation("Series", func(q *bun.SelectQuery) *bun.SelectQuery {
|
|
return q.Order("ps.series_number ASC")
|
|
}).
|
|
Relation("Series.Team1").
|
|
Relation("Series.Team2").
|
|
Relation("Series.Winner").
|
|
Relation("Series.Loser").
|
|
Relation("Series.Matches", func(q *bun.SelectQuery) *bun.SelectQuery {
|
|
return q.Order("pm.match_number ASC")
|
|
}).
|
|
Get(ctx)
|
|
}
|
|
|
|
// NewPlayoffSeries creates a new series within a bracket
|
|
func NewPlayoffSeries(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
bracket *PlayoffBracket,
|
|
seriesNumber int,
|
|
round, label string,
|
|
team1ID, team2ID *int,
|
|
team1Seed, team2Seed *int,
|
|
matchesToWin int,
|
|
status SeriesStatus,
|
|
) (*PlayoffSeries, error) {
|
|
series := &PlayoffSeries{
|
|
BracketID: bracket.ID,
|
|
SeriesNumber: seriesNumber,
|
|
Round: round,
|
|
Label: label,
|
|
Team1ID: team1ID,
|
|
Team2ID: team2ID,
|
|
Team1Seed: team1Seed,
|
|
Team2Seed: team2Seed,
|
|
MatchesToWin: matchesToWin,
|
|
Status: status,
|
|
CreatedAt: time.Now().Unix(),
|
|
}
|
|
err := Insert(tx, series).Exec(ctx)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "Insert")
|
|
}
|
|
return series, nil
|
|
}
|
|
|
|
// SetSeriesAdvancement sets the advancement links for a series
|
|
func SetSeriesAdvancement(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
seriesID int,
|
|
winnerNextID *int,
|
|
winnerNextSlot *string,
|
|
loserNextID *int,
|
|
loserNextSlot *string,
|
|
) error {
|
|
_, err := tx.NewUpdate().
|
|
Model((*PlayoffSeries)(nil)).
|
|
Set("winner_next_series_id = ?", winnerNextID).
|
|
Set("winner_next_slot = ?", winnerNextSlot).
|
|
Set("loser_next_series_id = ?", loserNextID).
|
|
Set("loser_next_slot = ?", loserNextSlot).
|
|
Where("id = ?", seriesID).
|
|
Exec(ctx)
|
|
if err != nil {
|
|
return errors.Wrap(err, "tx.NewUpdate")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// CountUnplayedFixtures counts fixtures without finalized results for a season+league
|
|
func CountUnplayedFixtures(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
seasonID, leagueID int,
|
|
) (int, error) {
|
|
count, err := tx.NewSelect().
|
|
Model((*Fixture)(nil)).
|
|
Where("f.season_id = ?", seasonID).
|
|
Where("f.league_id = ?", leagueID).
|
|
Where("f.game_week IS NOT NULL").
|
|
Where("NOT EXISTS (SELECT 1 FROM fixture_results fr WHERE fr.fixture_id = f.id AND fr.finalized = true)").
|
|
Count(ctx)
|
|
if err != nil {
|
|
return 0, errors.Wrap(err, "tx.NewSelect.Count")
|
|
}
|
|
return count, nil
|
|
}
|
|
|
|
// GetUnplayedFixtures returns all fixtures without finalized results for a season+league
|
|
func GetUnplayedFixtures(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
seasonID, leagueID int,
|
|
) ([]*Fixture, error) {
|
|
fixtures, err := GetList[Fixture](tx).
|
|
Where("f.season_id = ?", seasonID).
|
|
Where("f.league_id = ?", leagueID).
|
|
Where("f.game_week IS NOT NULL").
|
|
Where("NOT EXISTS (SELECT 1 FROM fixture_results fr WHERE fr.fixture_id = f.id AND fr.finalized = true)").
|
|
Order("f.game_week ASC", "f.round ASC", "f.id ASC").
|
|
Relation("HomeTeam").
|
|
Relation("AwayTeam").
|
|
GetAll(ctx)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "GetList")
|
|
}
|
|
return fixtures, nil
|
|
}
|
|
|
|
// AutoForfeitUnplayedFixtures creates mutual forfeit results for all unplayed fixtures
|
|
func AutoForfeitUnplayedFixtures(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
seasonID, leagueID int,
|
|
userID int,
|
|
audit *AuditMeta,
|
|
) (int, error) {
|
|
unplayed, err := GetUnplayedFixtures(ctx, tx, seasonID, leagueID)
|
|
if err != nil {
|
|
return 0, errors.Wrap(err, "GetUnplayedFixtures")
|
|
}
|
|
|
|
reason := "Auto-forfeited: regular season ended for finals"
|
|
for _, fixture := range unplayed {
|
|
// Check if a result already exists (non-finalized)
|
|
existing, err := GetFixtureResult(ctx, tx, fixture.ID)
|
|
if err != nil {
|
|
return 0, errors.Wrap(err, "GetFixtureResult")
|
|
}
|
|
if existing != nil {
|
|
// Skip fixtures that already have any result
|
|
continue
|
|
}
|
|
|
|
_, err = CreateForfeitResult(ctx, tx, fixture,
|
|
ForfeitTypeMutual, "", reason, userID, audit)
|
|
if err != nil {
|
|
return 0, errors.Wrap(err, "CreateForfeitResult")
|
|
}
|
|
}
|
|
|
|
return len(unplayed), nil
|
|
}
|