1034 lines
31 KiB
Go
1034 lines
31 KiB
Go
package db
|
|
|
|
import (
|
|
"context"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/pkg/errors"
|
|
"github.com/uptrace/bun"
|
|
)
|
|
|
|
type FixtureResult struct {
|
|
bun.BaseModel `bun:"table:fixture_results,alias:fr"`
|
|
|
|
ID int `bun:"id,pk,autoincrement"`
|
|
FixtureID int `bun:",notnull,unique"`
|
|
Winner string `bun:",notnull"`
|
|
HomeScore int `bun:",notnull"`
|
|
AwayScore int `bun:",notnull"`
|
|
MatchType string
|
|
Arena string
|
|
EndReason string
|
|
PeriodsEnabled bool
|
|
CustomMercyRule int
|
|
MatchLength int
|
|
CreatedAt int64 `bun:",notnull"`
|
|
UpdatedAt *int64
|
|
UploadedByUserID int `bun:",notnull"`
|
|
Finalized bool `bun:",default:false"`
|
|
TamperingDetected bool `bun:",default:false"`
|
|
TamperingReason *string
|
|
|
|
// Forfeit-related fields
|
|
IsForfeit bool `bun:"is_forfeit,default:false"`
|
|
ForfeitType *string `bun:"forfeit_type"` // "mutual" or "outright"
|
|
ForfeitTeam *string `bun:"forfeit_team"` // "home" or "away" (nil for mutual)
|
|
ForfeitReason *string `bun:"forfeit_reason"` // User-provided reason
|
|
|
|
Fixture *Fixture `bun:"rel:belongs-to,join:fixture_id=id"`
|
|
UploadedBy *User `bun:"rel:belongs-to,join:uploaded_by_user_id=id"`
|
|
PlayerStats []*FixtureResultPlayerStats `bun:"rel:has-many,join:id=fixture_result_id"`
|
|
}
|
|
|
|
type FixtureResultPlayerStats struct {
|
|
bun.BaseModel `bun:"table:fixture_result_player_stats,alias:frps"`
|
|
|
|
ID int `bun:"id,pk,autoincrement"`
|
|
FixtureResultID int `bun:",notnull"`
|
|
PeriodNum int `bun:",notnull"`
|
|
PlayerID *int // NULL for unmapped/free agents
|
|
PlayerGameUserID string `bun:",notnull"`
|
|
PlayerUsername string `bun:",notnull"`
|
|
TeamID *int // NULL for unmapped
|
|
Team string `bun:",notnull"` // 'home' or 'away'
|
|
|
|
// All stats as INT (nullable)
|
|
Goals *int
|
|
Assists *int
|
|
PrimaryAssists *int
|
|
SecondaryAssists *int
|
|
Saves *int
|
|
Blocks *int
|
|
Shots *int
|
|
Turnovers *int
|
|
Takeaways *int
|
|
Passes *int
|
|
PossessionTimeSec *int
|
|
FaceoffsWon *int
|
|
FaceoffsLost *int
|
|
PostHits *int
|
|
OvertimeGoals *int
|
|
GameWinningGoals *int
|
|
Score *int
|
|
ContributedGoals *int
|
|
ConcededGoals *int
|
|
GamesPlayed *int
|
|
Wins *int
|
|
Losses *int
|
|
OvertimeWins *int
|
|
OvertimeLosses *int
|
|
Ties *int
|
|
Shutouts *int
|
|
ShutoutsAgainst *int
|
|
HasMercyRuled *int
|
|
WasMercyRuled *int
|
|
PeriodsPlayed *int
|
|
IsFreeAgent bool `bun:"is_free_agent,default:false"`
|
|
|
|
FixtureResult *FixtureResult `bun:"rel:belongs-to,join:fixture_result_id=id"`
|
|
Player *Player `bun:"rel:belongs-to,join:player_id=id"`
|
|
TeamRel *Team `bun:"rel:belongs-to,join:team_id=id"`
|
|
}
|
|
|
|
// PlayerWithPlayStatus is a helper struct for overview display
|
|
type PlayerWithPlayStatus struct {
|
|
Player *Player
|
|
Played bool
|
|
IsManager bool
|
|
IsFreeAgent bool
|
|
Stats *FixtureResultPlayerStats // Period 3 (final cumulative) stats, nil if no result
|
|
}
|
|
|
|
// Forfeit type constants
|
|
const (
|
|
ForfeitTypeMutual = "mutual"
|
|
ForfeitTypeOutright = "outright"
|
|
)
|
|
|
|
// CreateForfeitResult creates a finalized forfeit result for a fixture.
|
|
// For outright forfeits, forfeitTeam specifies which team ("home" or "away") forfeited.
|
|
// For mutual forfeits, forfeitTeam should be empty.
|
|
func CreateForfeitResult(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
fixture *Fixture,
|
|
forfeitType string,
|
|
forfeitTeam string,
|
|
reason string,
|
|
userID int,
|
|
audit *AuditMeta,
|
|
) (*FixtureResult, error) {
|
|
if fixture == nil {
|
|
return nil, errors.New("fixture cannot be nil")
|
|
}
|
|
|
|
// Validate forfeit type
|
|
if forfeitType != ForfeitTypeMutual && forfeitType != ForfeitTypeOutright {
|
|
return nil, BadRequest("invalid forfeit type: must be 'mutual' or 'outright'")
|
|
}
|
|
|
|
// Validate forfeit team for outright forfeits
|
|
if forfeitType == ForfeitTypeOutright {
|
|
if forfeitTeam != "home" && forfeitTeam != "away" {
|
|
return nil, BadRequest("outright forfeit requires a team: must be 'home' or 'away'")
|
|
}
|
|
}
|
|
|
|
// Determine winner and scores based on forfeit type
|
|
var winner string
|
|
var homeScore, awayScore int
|
|
var endReason string
|
|
var forfeitTeamPtr *string
|
|
|
|
switch forfeitType {
|
|
case ForfeitTypeMutual:
|
|
// Mutual forfeit: both teams get an OT loss, no winner
|
|
// Use "draw" as winner to signal mutual loss
|
|
winner = "draw"
|
|
homeScore = 0
|
|
awayScore = 0
|
|
endReason = "Forfeit"
|
|
case ForfeitTypeOutright:
|
|
// Outright forfeit: forfeiting team loses, opponent wins
|
|
forfeitTeamPtr = &forfeitTeam
|
|
if forfeitTeam == "home" {
|
|
winner = "away"
|
|
} else {
|
|
winner = "home"
|
|
}
|
|
homeScore = 0
|
|
awayScore = 0
|
|
endReason = "Forfeit"
|
|
}
|
|
|
|
var reasonPtr *string
|
|
if reason != "" {
|
|
reasonPtr = &reason
|
|
}
|
|
|
|
result := &FixtureResult{
|
|
FixtureID: fixture.ID,
|
|
Winner: winner,
|
|
HomeScore: homeScore,
|
|
AwayScore: awayScore,
|
|
EndReason: endReason,
|
|
UploadedByUserID: userID,
|
|
Finalized: true, // Forfeits are immediately finalized
|
|
IsForfeit: true,
|
|
ForfeitType: &forfeitType,
|
|
ForfeitTeam: forfeitTeamPtr,
|
|
ForfeitReason: reasonPtr,
|
|
CreatedAt: time.Now().Unix(),
|
|
}
|
|
|
|
err := Insert(tx, result).WithAudit(audit, &AuditInfo{
|
|
Action: "fixture_results.forfeit",
|
|
ResourceType: "fixture_result",
|
|
ResourceID: nil,
|
|
Details: map[string]any{
|
|
"fixture_id": fixture.ID,
|
|
"forfeit_type": forfeitType,
|
|
"forfeit_team": forfeitTeam,
|
|
"reason": reason,
|
|
},
|
|
}).Exec(ctx)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "Insert forfeit result")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// InsertFixtureResult stores a new match result with all player stats in a single transaction.
|
|
func InsertFixtureResult(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
result *FixtureResult,
|
|
playerStats []*FixtureResultPlayerStats,
|
|
audit *AuditMeta,
|
|
) (*FixtureResult, error) {
|
|
if result == nil {
|
|
return nil, errors.New("result cannot be nil")
|
|
}
|
|
|
|
result.CreatedAt = time.Now().Unix()
|
|
|
|
err := Insert(tx, result).WithAudit(audit, &AuditInfo{
|
|
Action: "fixture_results.create",
|
|
ResourceType: "fixture_result",
|
|
ResourceID: nil,
|
|
Details: map[string]any{
|
|
"fixture_id": result.FixtureID,
|
|
"winner": result.Winner,
|
|
"home_score": result.HomeScore,
|
|
"away_score": result.AwayScore,
|
|
"tampering_detected": result.TamperingDetected,
|
|
},
|
|
}).Exec(ctx)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "Insert result")
|
|
}
|
|
|
|
// Set the fixture_result_id on all player stats
|
|
for _, ps := range playerStats {
|
|
ps.FixtureResultID = result.ID
|
|
}
|
|
|
|
// Insert player stats in bulk
|
|
if len(playerStats) > 0 {
|
|
err = InsertMultiple(tx, playerStats).Exec(ctx)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "InsertMultiple player stats")
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// GetFixtureResult retrieves a result with all player stats for a fixture.
|
|
// Returns nil, nil if no result exists.
|
|
func GetFixtureResult(ctx context.Context, tx bun.Tx, fixtureID int) (*FixtureResult, error) {
|
|
result := new(FixtureResult)
|
|
err := tx.NewSelect().
|
|
Model(result).
|
|
Where("fr.fixture_id = ?", fixtureID).
|
|
Relation("Fixture").
|
|
Relation("UploadedBy").
|
|
Relation("PlayerStats", func(q *bun.SelectQuery) *bun.SelectQuery {
|
|
return q.Order("frps.team ASC", "frps.period_num ASC", "frps.player_username ASC")
|
|
}).
|
|
Relation("PlayerStats.Player").
|
|
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 result, nil
|
|
}
|
|
|
|
// GetPendingFixtureResult retrieves a non-finalized result for review/edit.
|
|
// Returns nil, nil if no pending result exists.
|
|
func GetPendingFixtureResult(ctx context.Context, tx bun.Tx, fixtureID int) (*FixtureResult, error) {
|
|
result := new(FixtureResult)
|
|
err := tx.NewSelect().
|
|
Model(result).
|
|
Where("fr.fixture_id = ?", fixtureID).
|
|
Where("fr.finalized = false").
|
|
Relation("Fixture").
|
|
Relation("UploadedBy").
|
|
Relation("PlayerStats", func(q *bun.SelectQuery) *bun.SelectQuery {
|
|
return q.Order("frps.team ASC", "frps.period_num ASC", "frps.player_username ASC")
|
|
}).
|
|
Relation("PlayerStats.Player").
|
|
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 result, nil
|
|
}
|
|
|
|
// FinalizeFixtureResult marks a pending result as finalized.
|
|
func FinalizeFixtureResult(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
fixtureID int,
|
|
audit *AuditMeta,
|
|
) error {
|
|
result, err := GetPendingFixtureResult(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
return errors.Wrap(err, "GetPendingFixtureResult")
|
|
}
|
|
if result == nil {
|
|
return BadRequest("no pending result to finalize")
|
|
}
|
|
|
|
now := time.Now().Unix()
|
|
result.Finalized = true
|
|
result.UpdatedAt = &now
|
|
|
|
err = UpdateByID(tx, result.ID, result).
|
|
Column("finalized", "updated_at").
|
|
WithAudit(audit, &AuditInfo{
|
|
Action: "fixture_results.finalize",
|
|
ResourceType: "fixture_result",
|
|
ResourceID: result.ID,
|
|
Details: map[string]any{
|
|
"fixture_id": fixtureID,
|
|
},
|
|
}).Exec(ctx)
|
|
if err != nil {
|
|
return errors.Wrap(err, "UpdateByID")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// DeleteFixtureResult removes a pending result and all associated player stats (CASCADE).
|
|
func DeleteFixtureResult(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
fixtureID int,
|
|
audit *AuditMeta,
|
|
) error {
|
|
result, err := GetPendingFixtureResult(ctx, tx, fixtureID)
|
|
if err != nil {
|
|
return errors.Wrap(err, "GetPendingFixtureResult")
|
|
}
|
|
if result == nil {
|
|
return BadRequest("no pending result to discard")
|
|
}
|
|
|
|
err = DeleteByID[FixtureResult](tx, result.ID).
|
|
WithAudit(audit, &AuditInfo{
|
|
Action: "fixture_results.discard",
|
|
ResourceType: "fixture_result",
|
|
ResourceID: result.ID,
|
|
Details: map[string]any{
|
|
"fixture_id": fixtureID,
|
|
},
|
|
}).Delete(ctx)
|
|
if err != nil {
|
|
return errors.Wrap(err, "DeleteByID")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// GetFinalizedResultsForFixtures returns finalized results for a list of fixture IDs.
|
|
// Returns a map of fixtureID -> *FixtureResult (without player stats for efficiency).
|
|
func GetFinalizedResultsForFixtures(ctx context.Context, tx bun.Tx, fixtureIDs []int) (map[int]*FixtureResult, error) {
|
|
if len(fixtureIDs) == 0 {
|
|
return map[int]*FixtureResult{}, nil
|
|
}
|
|
results, err := GetList[FixtureResult](tx).
|
|
Where("fixture_id IN (?)", bun.In(fixtureIDs)).
|
|
Where("finalized = true").
|
|
GetAll(ctx)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "GetList")
|
|
}
|
|
resultMap := make(map[int]*FixtureResult, len(results))
|
|
for _, r := range results {
|
|
resultMap[r.FixtureID] = r
|
|
}
|
|
return resultMap, nil
|
|
}
|
|
|
|
// AggregatedPlayerStats holds summed stats for a player across multiple fixtures.
|
|
type AggregatedPlayerStats struct {
|
|
PlayerID int `bun:"player_id"`
|
|
PlayerName string `bun:"player_name"`
|
|
GamesPlayed int `bun:"games_played"`
|
|
PeriodsPlayed int `bun:"total_periods_played"`
|
|
Score int `bun:"total_score"`
|
|
Goals int `bun:"total_goals"`
|
|
Assists int `bun:"total_assists"`
|
|
Saves int `bun:"total_saves"`
|
|
Shots int `bun:"total_shots"`
|
|
Blocks int `bun:"total_blocks"`
|
|
Passes int `bun:"total_passes"`
|
|
}
|
|
|
|
// GetAggregatedPlayerStatsForTeam returns aggregated period-3 stats for all mapped
|
|
// players on a given team across all finalized fixture results.
|
|
func GetAggregatedPlayerStatsForTeam(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
teamID int,
|
|
fixtureIDs []int,
|
|
) ([]*AggregatedPlayerStats, error) {
|
|
if len(fixtureIDs) == 0 {
|
|
return nil, nil
|
|
}
|
|
|
|
var stats []*AggregatedPlayerStats
|
|
err := tx.NewRaw(`
|
|
SELECT
|
|
frps.player_id AS player_id,
|
|
COALESCE(p.name, frps.player_username) AS player_name,
|
|
COUNT(DISTINCT frps.fixture_result_id) AS games_played,
|
|
COALESCE(SUM(frps.periods_played), 0) AS total_periods_played,
|
|
COALESCE(SUM(frps.score), 0) AS total_score,
|
|
COALESCE(SUM(frps.goals), 0) AS total_goals,
|
|
COALESCE(SUM(frps.assists), 0) AS total_assists,
|
|
COALESCE(SUM(frps.saves), 0) AS total_saves,
|
|
COALESCE(SUM(frps.shots), 0) AS total_shots,
|
|
COALESCE(SUM(frps.blocks), 0) AS total_blocks,
|
|
COALESCE(SUM(frps.passes), 0) AS total_passes
|
|
FROM fixture_result_player_stats frps
|
|
JOIN fixture_results fr ON fr.id = frps.fixture_result_id
|
|
LEFT JOIN players p ON p.id = frps.player_id
|
|
WHERE fr.finalized = true
|
|
AND fr.fixture_id IN (?)
|
|
AND frps.team_id = ?
|
|
AND frps.period_num = 3
|
|
AND frps.player_id IS NOT NULL
|
|
GROUP BY frps.player_id, COALESCE(p.name, frps.player_username)
|
|
ORDER BY total_score DESC
|
|
`, bun.In(fixtureIDs), teamID).Scan(ctx, &stats)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "tx.NewRaw")
|
|
}
|
|
return stats, nil
|
|
}
|
|
|
|
// LeaguePlayerStats holds all aggregated stats for a player in a season-league.
|
|
type LeaguePlayerStats struct {
|
|
PlayerID int `bun:"player_id"`
|
|
PlayerName string `bun:"player_name"`
|
|
TeamID int `bun:"team_id"`
|
|
TeamName string `bun:"team_name"`
|
|
TeamColor string `bun:"team_color"`
|
|
GamesPlayed int `bun:"games_played"`
|
|
PeriodsPlayed int `bun:"total_periods_played"`
|
|
Goals int `bun:"total_goals"`
|
|
Assists int `bun:"total_assists"`
|
|
PrimaryAssists int `bun:"total_primary_assists"`
|
|
SecondaryAssists int `bun:"total_secondary_assists"`
|
|
Saves int `bun:"total_saves"`
|
|
Shots int `bun:"total_shots"`
|
|
Blocks int `bun:"total_blocks"`
|
|
Passes int `bun:"total_passes"`
|
|
Score int `bun:"total_score"`
|
|
}
|
|
|
|
// GetAllLeaguePlayerStats returns aggregated stats for all players in a season-league.
|
|
// Stats are combined across all teams a player may have played on,
|
|
// and the player's current roster team is shown.
|
|
func GetAllLeaguePlayerStats(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
seasonID, leagueID int,
|
|
) ([]*LeaguePlayerStats, error) {
|
|
if seasonID == 0 {
|
|
return nil, errors.New("seasonID not provided")
|
|
}
|
|
if leagueID == 0 {
|
|
return nil, errors.New("leagueID not provided")
|
|
}
|
|
|
|
var stats []*LeaguePlayerStats
|
|
err := tx.NewRaw(`
|
|
SELECT
|
|
agg.player_id,
|
|
agg.player_name,
|
|
COALESCE(tr.team_id, 0) AS team_id,
|
|
COALESCE(t.name, '') AS team_name,
|
|
COALESCE(t.color, '') AS team_color,
|
|
agg.games_played,
|
|
agg.total_periods_played,
|
|
agg.total_goals,
|
|
agg.total_assists,
|
|
agg.total_primary_assists,
|
|
agg.total_secondary_assists,
|
|
agg.total_saves,
|
|
agg.total_shots,
|
|
agg.total_blocks,
|
|
agg.total_passes,
|
|
agg.total_score
|
|
FROM (
|
|
SELECT
|
|
frps.player_id AS player_id,
|
|
COALESCE(p.name, frps.player_username) AS player_name,
|
|
COUNT(DISTINCT frps.fixture_result_id) AS games_played,
|
|
COALESCE(SUM(frps.periods_played), 0) AS total_periods_played,
|
|
COALESCE(SUM(frps.goals), 0) AS total_goals,
|
|
COALESCE(SUM(frps.assists), 0) AS total_assists,
|
|
COALESCE(SUM(frps.primary_assists), 0) AS total_primary_assists,
|
|
COALESCE(SUM(frps.secondary_assists), 0) AS total_secondary_assists,
|
|
COALESCE(SUM(frps.saves), 0) AS total_saves,
|
|
COALESCE(SUM(frps.shots), 0) AS total_shots,
|
|
COALESCE(SUM(frps.blocks), 0) AS total_blocks,
|
|
COALESCE(SUM(frps.passes), 0) AS total_passes,
|
|
COALESCE(SUM(frps.score), 0) AS total_score
|
|
FROM fixture_result_player_stats frps
|
|
JOIN fixture_results fr ON fr.id = frps.fixture_result_id
|
|
JOIN fixtures f ON f.id = fr.fixture_id
|
|
LEFT JOIN players p ON p.id = frps.player_id
|
|
WHERE fr.finalized = true
|
|
AND f.season_id = ?
|
|
AND f.league_id = ?
|
|
AND frps.period_num = 3
|
|
AND frps.player_id IS NOT NULL
|
|
GROUP BY frps.player_id, COALESCE(p.name, frps.player_username)
|
|
) agg
|
|
LEFT JOIN team_rosters tr
|
|
ON tr.player_id = agg.player_id
|
|
AND tr.season_id = ?
|
|
AND tr.league_id = ?
|
|
LEFT JOIN teams t ON t.id = tr.team_id
|
|
ORDER BY agg.total_score DESC
|
|
`, seasonID, leagueID, seasonID, leagueID).Scan(ctx, &stats)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "tx.NewRaw")
|
|
}
|
|
return stats, nil
|
|
}
|
|
|
|
// LeagueTopGoalScorer holds aggregated goal scoring stats for a player in a season-league.
|
|
type LeagueTopGoalScorer struct {
|
|
PlayerID int `bun:"player_id"`
|
|
PlayerName string `bun:"player_name"`
|
|
TeamID int `bun:"team_id"`
|
|
TeamName string `bun:"team_name"`
|
|
TeamColor string `bun:"team_color"`
|
|
Goals int `bun:"total_goals"`
|
|
PeriodsPlayed int `bun:"total_periods_played"`
|
|
Shots int `bun:"total_shots"`
|
|
}
|
|
|
|
// GetTopGoalScorers returns the top goal scorers for a season-league,
|
|
// sorted by goals DESC, periods ASC, shots ASC.
|
|
// Stats are combined across all teams a player may have played on,
|
|
// and the player's current roster team is shown.
|
|
func GetTopGoalScorers(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
seasonID, leagueID int,
|
|
) ([]*LeagueTopGoalScorer, error) {
|
|
if seasonID == 0 {
|
|
return nil, errors.New("seasonID not provided")
|
|
}
|
|
if leagueID == 0 {
|
|
return nil, errors.New("leagueID not provided")
|
|
}
|
|
|
|
var stats []*LeagueTopGoalScorer
|
|
err := tx.NewRaw(`
|
|
SELECT
|
|
agg.player_id,
|
|
agg.player_name,
|
|
COALESCE(tr.team_id, 0) AS team_id,
|
|
COALESCE(t.name, '') AS team_name,
|
|
COALESCE(t.color, '') AS team_color,
|
|
agg.total_goals,
|
|
agg.total_periods_played,
|
|
agg.total_shots
|
|
FROM (
|
|
SELECT
|
|
frps.player_id AS player_id,
|
|
COALESCE(p.name, frps.player_username) AS player_name,
|
|
COALESCE(SUM(frps.goals), 0) AS total_goals,
|
|
COALESCE(SUM(frps.periods_played), 0) AS total_periods_played,
|
|
COALESCE(SUM(frps.shots), 0) AS total_shots
|
|
FROM fixture_result_player_stats frps
|
|
JOIN fixture_results fr ON fr.id = frps.fixture_result_id
|
|
JOIN fixtures f ON f.id = fr.fixture_id
|
|
LEFT JOIN players p ON p.id = frps.player_id
|
|
WHERE fr.finalized = true
|
|
AND f.season_id = ?
|
|
AND f.league_id = ?
|
|
AND frps.period_num = 3
|
|
AND frps.player_id IS NOT NULL
|
|
GROUP BY frps.player_id, COALESCE(p.name, frps.player_username)
|
|
ORDER BY total_goals DESC, total_periods_played ASC, total_shots ASC
|
|
LIMIT 10
|
|
) agg
|
|
LEFT JOIN team_rosters tr
|
|
ON tr.player_id = agg.player_id
|
|
AND tr.season_id = ?
|
|
AND tr.league_id = ?
|
|
LEFT JOIN teams t ON t.id = tr.team_id
|
|
ORDER BY agg.total_goals DESC, agg.total_periods_played ASC, agg.total_shots ASC
|
|
`, seasonID, leagueID, seasonID, leagueID).Scan(ctx, &stats)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "tx.NewRaw")
|
|
}
|
|
return stats, nil
|
|
}
|
|
|
|
// LeagueTopAssister holds aggregated assist stats for a player in a season-league.
|
|
type LeagueTopAssister struct {
|
|
PlayerID int `bun:"player_id"`
|
|
PlayerName string `bun:"player_name"`
|
|
TeamID int `bun:"team_id"`
|
|
TeamName string `bun:"team_name"`
|
|
TeamColor string `bun:"team_color"`
|
|
Assists int `bun:"total_assists"`
|
|
PeriodsPlayed int `bun:"total_periods_played"`
|
|
PrimaryAssists int `bun:"total_primary_assists"`
|
|
}
|
|
|
|
// GetTopAssisters returns the top assisters for a season-league,
|
|
// sorted by assists DESC, periods ASC, primary assists DESC.
|
|
// Stats are combined across all teams a player may have played on,
|
|
// and the player's current roster team is shown.
|
|
func GetTopAssisters(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
seasonID, leagueID int,
|
|
) ([]*LeagueTopAssister, error) {
|
|
if seasonID == 0 {
|
|
return nil, errors.New("seasonID not provided")
|
|
}
|
|
if leagueID == 0 {
|
|
return nil, errors.New("leagueID not provided")
|
|
}
|
|
|
|
var stats []*LeagueTopAssister
|
|
err := tx.NewRaw(`
|
|
SELECT
|
|
agg.player_id,
|
|
agg.player_name,
|
|
COALESCE(tr.team_id, 0) AS team_id,
|
|
COALESCE(t.name, '') AS team_name,
|
|
COALESCE(t.color, '') AS team_color,
|
|
agg.total_assists,
|
|
agg.total_periods_played,
|
|
agg.total_primary_assists
|
|
FROM (
|
|
SELECT
|
|
frps.player_id AS player_id,
|
|
COALESCE(p.name, frps.player_username) AS player_name,
|
|
COALESCE(SUM(frps.assists), 0) AS total_assists,
|
|
COALESCE(SUM(frps.periods_played), 0) AS total_periods_played,
|
|
COALESCE(SUM(frps.primary_assists), 0) AS total_primary_assists
|
|
FROM fixture_result_player_stats frps
|
|
JOIN fixture_results fr ON fr.id = frps.fixture_result_id
|
|
JOIN fixtures f ON f.id = fr.fixture_id
|
|
LEFT JOIN players p ON p.id = frps.player_id
|
|
WHERE fr.finalized = true
|
|
AND f.season_id = ?
|
|
AND f.league_id = ?
|
|
AND frps.period_num = 3
|
|
AND frps.player_id IS NOT NULL
|
|
GROUP BY frps.player_id, COALESCE(p.name, frps.player_username)
|
|
ORDER BY total_assists DESC, total_periods_played ASC, total_primary_assists DESC
|
|
LIMIT 10
|
|
) agg
|
|
LEFT JOIN team_rosters tr
|
|
ON tr.player_id = agg.player_id
|
|
AND tr.season_id = ?
|
|
AND tr.league_id = ?
|
|
LEFT JOIN teams t ON t.id = tr.team_id
|
|
ORDER BY agg.total_assists DESC, agg.total_periods_played ASC, agg.total_primary_assists DESC
|
|
`, seasonID, leagueID, seasonID, leagueID).Scan(ctx, &stats)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "tx.NewRaw")
|
|
}
|
|
return stats, nil
|
|
}
|
|
|
|
// LeagueTopSaver holds aggregated save stats for a player in a season-league.
|
|
type LeagueTopSaver struct {
|
|
PlayerID int `bun:"player_id"`
|
|
PlayerName string `bun:"player_name"`
|
|
TeamID int `bun:"team_id"`
|
|
TeamName string `bun:"team_name"`
|
|
TeamColor string `bun:"team_color"`
|
|
Saves int `bun:"total_saves"`
|
|
PeriodsPlayed int `bun:"total_periods_played"`
|
|
Blocks int `bun:"total_blocks"`
|
|
}
|
|
|
|
// GetTopSavers returns the top savers for a season-league,
|
|
// sorted by saves DESC, periods ASC, blocks DESC.
|
|
// Stats are combined across all teams a player may have played on,
|
|
// and the player's current roster team is shown.
|
|
func GetTopSavers(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
seasonID, leagueID int,
|
|
) ([]*LeagueTopSaver, error) {
|
|
if seasonID == 0 {
|
|
return nil, errors.New("seasonID not provided")
|
|
}
|
|
if leagueID == 0 {
|
|
return nil, errors.New("leagueID not provided")
|
|
}
|
|
|
|
var stats []*LeagueTopSaver
|
|
err := tx.NewRaw(`
|
|
SELECT
|
|
agg.player_id,
|
|
agg.player_name,
|
|
COALESCE(tr.team_id, 0) AS team_id,
|
|
COALESCE(t.name, '') AS team_name,
|
|
COALESCE(t.color, '') AS team_color,
|
|
agg.total_saves,
|
|
agg.total_periods_played,
|
|
agg.total_blocks
|
|
FROM (
|
|
SELECT
|
|
frps.player_id AS player_id,
|
|
COALESCE(p.name, frps.player_username) AS player_name,
|
|
COALESCE(SUM(frps.saves), 0) AS total_saves,
|
|
COALESCE(SUM(frps.periods_played), 0) AS total_periods_played,
|
|
COALESCE(SUM(frps.blocks), 0) AS total_blocks
|
|
FROM fixture_result_player_stats frps
|
|
JOIN fixture_results fr ON fr.id = frps.fixture_result_id
|
|
JOIN fixtures f ON f.id = fr.fixture_id
|
|
LEFT JOIN players p ON p.id = frps.player_id
|
|
WHERE fr.finalized = true
|
|
AND f.season_id = ?
|
|
AND f.league_id = ?
|
|
AND frps.period_num = 3
|
|
AND frps.player_id IS NOT NULL
|
|
GROUP BY frps.player_id, COALESCE(p.name, frps.player_username)
|
|
ORDER BY total_saves DESC, total_periods_played ASC, total_blocks DESC
|
|
LIMIT 10
|
|
) agg
|
|
LEFT JOIN team_rosters tr
|
|
ON tr.player_id = agg.player_id
|
|
AND tr.season_id = ?
|
|
AND tr.league_id = ?
|
|
LEFT JOIN teams t ON t.id = tr.team_id
|
|
ORDER BY agg.total_saves DESC, agg.total_periods_played ASC, agg.total_blocks DESC
|
|
`, seasonID, leagueID, seasonID, leagueID).Scan(ctx, &stats)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "tx.NewRaw")
|
|
}
|
|
return stats, nil
|
|
}
|
|
|
|
// TeamRecord holds win/loss/draw record and goal totals for a team.
|
|
type TeamRecord struct {
|
|
Played int
|
|
Wins int
|
|
OvertimeWins int
|
|
OvertimeLosses int
|
|
Losses int
|
|
Draws int
|
|
GoalsFor int
|
|
GoalsAgainst int
|
|
Points int
|
|
}
|
|
|
|
// Point values for the leaderboard scoring system.
|
|
const (
|
|
PointsWin = 3
|
|
PointsOvertimeWin = 2
|
|
PointsOvertimeLoss = 1
|
|
PointsLoss = 0
|
|
)
|
|
|
|
// ComputeTeamRecord calculates W-OTW-OTL-L, GF/GA, and points from fixtures and results.
|
|
// Points: Win=3, OT Win=2, OT Loss=1, Loss=0.
|
|
// Forfeits: Outright = Win(3)/Loss(0), Mutual = OT Loss(1) for both teams.
|
|
func ComputeTeamRecord(teamID int, fixtures []*Fixture, resultMap map[int]*FixtureResult) *TeamRecord {
|
|
rec := &TeamRecord{}
|
|
for _, f := range fixtures {
|
|
res, ok := resultMap[f.ID]
|
|
if !ok {
|
|
continue
|
|
}
|
|
rec.Played++
|
|
isHome := f.HomeTeamID == teamID
|
|
|
|
// Handle forfeits separately
|
|
if res.IsForfeit {
|
|
// Forfeits have 0-0 score, no goal impact
|
|
if res.ForfeitType != nil && *res.ForfeitType == ForfeitTypeMutual {
|
|
// Mutual forfeit: both teams get OT loss (1 point)
|
|
rec.OvertimeLosses++
|
|
rec.Points += PointsOvertimeLoss
|
|
} else if res.ForfeitType != nil && *res.ForfeitType == ForfeitTypeOutright {
|
|
// Outright forfeit: check if this team forfeited
|
|
thisSide := "away"
|
|
if isHome {
|
|
thisSide = "home"
|
|
}
|
|
if res.ForfeitTeam != nil && *res.ForfeitTeam == thisSide {
|
|
// This team forfeited - loss
|
|
rec.Losses++
|
|
rec.Points += PointsLoss
|
|
} else {
|
|
// Opponent forfeited - win
|
|
rec.Wins++
|
|
rec.Points += PointsWin
|
|
}
|
|
}
|
|
continue
|
|
}
|
|
|
|
// Normal match handling
|
|
if isHome {
|
|
rec.GoalsFor += res.HomeScore
|
|
rec.GoalsAgainst += res.AwayScore
|
|
} else {
|
|
rec.GoalsFor += res.AwayScore
|
|
rec.GoalsAgainst += res.HomeScore
|
|
}
|
|
won := (isHome && res.Winner == "home") || (!isHome && res.Winner == "away")
|
|
lost := (isHome && res.Winner == "away") || (!isHome && res.Winner == "home")
|
|
isOT := strings.EqualFold(res.EndReason, "Overtime")
|
|
|
|
switch {
|
|
case won && isOT:
|
|
rec.OvertimeWins++
|
|
rec.Points += PointsOvertimeWin
|
|
case won:
|
|
rec.Wins++
|
|
rec.Points += PointsWin
|
|
case lost && isOT:
|
|
rec.OvertimeLosses++
|
|
rec.Points += PointsOvertimeLoss
|
|
case lost:
|
|
rec.Losses++
|
|
rec.Points += PointsLoss
|
|
default:
|
|
rec.Draws++
|
|
}
|
|
}
|
|
return rec
|
|
}
|
|
|
|
// LeaderboardEntry represents a single team's standing in the league table.
|
|
type LeaderboardEntry struct {
|
|
Position int
|
|
Team *Team
|
|
Record *TeamRecord
|
|
}
|
|
|
|
// ComputeLeaderboard builds a sorted leaderboard from teams, fixtures, and results.
|
|
// Teams are sorted by: Points DESC, Goal Differential DESC, Goals For DESC, Name ASC.
|
|
func ComputeLeaderboard(teams []*Team, fixtures []*Fixture, resultMap map[int]*FixtureResult) []*LeaderboardEntry {
|
|
entries := make([]*LeaderboardEntry, 0, len(teams))
|
|
|
|
// Build a map of team ID -> fixtures involving that team
|
|
teamFixtures := make(map[int][]*Fixture)
|
|
for _, f := range fixtures {
|
|
teamFixtures[f.HomeTeamID] = append(teamFixtures[f.HomeTeamID], f)
|
|
teamFixtures[f.AwayTeamID] = append(teamFixtures[f.AwayTeamID], f)
|
|
}
|
|
|
|
for _, team := range teams {
|
|
record := ComputeTeamRecord(team.ID, teamFixtures[team.ID], resultMap)
|
|
entries = append(entries, &LeaderboardEntry{
|
|
Team: team,
|
|
Record: record,
|
|
})
|
|
}
|
|
|
|
// Sort: Points DESC, then goal diff DESC, then GF DESC, then name ASC
|
|
sort.Slice(entries, func(i, j int) bool {
|
|
ri, rj := entries[i].Record, entries[j].Record
|
|
if ri.Points != rj.Points {
|
|
return ri.Points > rj.Points
|
|
}
|
|
diffI := ri.GoalsFor - ri.GoalsAgainst
|
|
diffJ := rj.GoalsFor - rj.GoalsAgainst
|
|
if diffI != diffJ {
|
|
return diffI > diffJ
|
|
}
|
|
if ri.GoalsFor != rj.GoalsFor {
|
|
return ri.GoalsFor > rj.GoalsFor
|
|
}
|
|
return entries[i].Team.Name < entries[j].Team.Name
|
|
})
|
|
|
|
// Assign positions
|
|
for i := range entries {
|
|
entries[i].Position = i + 1
|
|
}
|
|
|
|
return entries
|
|
}
|
|
|
|
// GetFixtureTeamRosters returns all team players with participation status for a fixture.
|
|
// Returns: map["home"|"away"] -> []*PlayerWithPlayStatus
|
|
func GetFixtureTeamRosters(
|
|
ctx context.Context,
|
|
tx bun.Tx,
|
|
fixture *Fixture,
|
|
result *FixtureResult,
|
|
) (map[string][]*PlayerWithPlayStatus, error) {
|
|
if fixture == nil {
|
|
return nil, errors.New("fixture cannot be nil")
|
|
}
|
|
|
|
rosters := map[string][]*PlayerWithPlayStatus{}
|
|
|
|
// Get home team roster
|
|
homeRosters := []*TeamRoster{}
|
|
err := tx.NewSelect().
|
|
Model(&homeRosters).
|
|
Where("tr.team_id = ?", fixture.HomeTeamID).
|
|
Where("tr.season_id = ?", fixture.SeasonID).
|
|
Where("tr.league_id = ?", fixture.LeagueID).
|
|
Relation("Player", func(q *bun.SelectQuery) *bun.SelectQuery {
|
|
return q.Relation("User")
|
|
}).
|
|
Scan(ctx)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "tx.NewSelect home roster")
|
|
}
|
|
|
|
// Get away team roster
|
|
awayRosters := []*TeamRoster{}
|
|
err = tx.NewSelect().
|
|
Model(&awayRosters).
|
|
Where("tr.team_id = ?", fixture.AwayTeamID).
|
|
Where("tr.season_id = ?", fixture.SeasonID).
|
|
Where("tr.league_id = ?", fixture.LeagueID).
|
|
Relation("Player", func(q *bun.SelectQuery) *bun.SelectQuery {
|
|
return q.Relation("User")
|
|
}).
|
|
Scan(ctx)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "tx.NewSelect away roster")
|
|
}
|
|
|
|
// Build maps of player IDs that played and their period 3 stats
|
|
playedPlayerIDs := map[int]bool{}
|
|
playerStatsByID := map[int]*FixtureResultPlayerStats{}
|
|
freeAgentPlayerIDs := map[int]bool{}
|
|
// Track free agents by team side for roster inclusion
|
|
freeAgentsByTeam := map[string]map[int]*FixtureResultPlayerStats{} // "home"/"away" -> playerID -> stats
|
|
freeAgentsByTeam["home"] = map[int]*FixtureResultPlayerStats{}
|
|
freeAgentsByTeam["away"] = map[int]*FixtureResultPlayerStats{}
|
|
|
|
if result != nil {
|
|
for _, ps := range result.PlayerStats {
|
|
if ps.PlayerID != nil {
|
|
playedPlayerIDs[*ps.PlayerID] = true
|
|
if ps.PeriodNum == 3 {
|
|
playerStatsByID[*ps.PlayerID] = ps
|
|
}
|
|
if ps.IsFreeAgent {
|
|
freeAgentPlayerIDs[*ps.PlayerID] = true
|
|
if ps.PeriodNum == 3 {
|
|
freeAgentsByTeam[ps.Team][*ps.PlayerID] = ps
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Build a set of roster player IDs so we can skip them when adding free agents
|
|
rosterPlayerIDs := map[int]bool{}
|
|
for _, r := range homeRosters {
|
|
if r.Player != nil {
|
|
rosterPlayerIDs[r.Player.ID] = true
|
|
}
|
|
}
|
|
for _, r := range awayRosters {
|
|
if r.Player != nil {
|
|
rosterPlayerIDs[r.Player.ID] = true
|
|
}
|
|
}
|
|
|
|
// Build home roster with play status and stats
|
|
for _, r := range homeRosters {
|
|
played := false
|
|
var stats *FixtureResultPlayerStats
|
|
if result != nil && r.Player != nil {
|
|
played = playedPlayerIDs[r.Player.ID]
|
|
stats = playerStatsByID[r.Player.ID]
|
|
}
|
|
rosters["home"] = append(rosters["home"], &PlayerWithPlayStatus{
|
|
Player: r.Player,
|
|
Played: played,
|
|
IsManager: r.IsManager,
|
|
Stats: stats,
|
|
})
|
|
}
|
|
|
|
// Build away roster with play status and stats
|
|
for _, r := range awayRosters {
|
|
played := false
|
|
var stats *FixtureResultPlayerStats
|
|
if result != nil && r.Player != nil {
|
|
played = playedPlayerIDs[r.Player.ID]
|
|
stats = playerStatsByID[r.Player.ID]
|
|
}
|
|
rosters["away"] = append(rosters["away"], &PlayerWithPlayStatus{
|
|
Player: r.Player,
|
|
Played: played,
|
|
IsManager: r.IsManager,
|
|
Stats: stats,
|
|
})
|
|
}
|
|
|
|
// Add free agents who played but are not on the team roster
|
|
for team, faStats := range freeAgentsByTeam {
|
|
for playerID, stats := range faStats {
|
|
if rosterPlayerIDs[playerID] {
|
|
continue // Already on the roster, skip
|
|
}
|
|
if stats.Player == nil {
|
|
// Try to load the player
|
|
player, err := GetPlayer(ctx, tx, playerID)
|
|
if err != nil {
|
|
continue // Skip if we can't load
|
|
}
|
|
stats.Player = player
|
|
}
|
|
rosters[team] = append(rosters[team], &PlayerWithPlayStatus{
|
|
Player: stats.Player,
|
|
Played: true,
|
|
IsManager: false,
|
|
IsFreeAgent: true,
|
|
Stats: stats,
|
|
})
|
|
}
|
|
}
|
|
|
|
return rosters, nil
|
|
}
|