Add player profiles and community settings

Co-authored-by: Cursor <cursoragent@cursor.com>

backend/internal/domain/player_profile.go

@@ -0,0 +1,169 @@
+package domain
+
+import (
+	"sort"
+	"strings"
+	"time"
+)
+
+type PublicPlayer struct {
+	ID          string  `json:"id"`
+	DisplayName string  `json:"displayName"`
+	BattleTag   string  `json:"battleTag"`
+	Ratings     Ratings `json:"ratings"`
+	IsGuest     bool    `json:"isGuest"`
+}
+
+type PlayerStatsSummary struct {
+	SeriesPlayed int     `json:"seriesPlayed"`
+	SeriesWon    int     `json:"seriesWon"`
+	SeriesLost   int     `json:"seriesLost"`
+	WinRate      float64 `json:"winRate"`
+	MapsPlayed   int     `json:"mapsPlayed"`
+	MapsWon      int     `json:"mapsWon"`
+	MapsLost     int     `json:"mapsLost"`
+	MapsDrawn    int     `json:"mapsDrawn"`
+}
+
+type PlayerMatchHistory struct {
+	SeriesID         string    `json:"seriesId"`
+	EventID          string    `json:"eventId"`
+	EventName        string    `json:"eventName"`
+	EventDate        time.Time `json:"eventDate"`
+	OwnTeamID        string    `json:"ownTeamId"`
+	OwnTeamName      string    `json:"ownTeamName"`
+	OpponentTeamID   string    `json:"opponentTeamId"`
+	OpponentTeamName string    `json:"opponentTeamName"`
+	OwnScore         int       `json:"ownScore"`
+	OpponentScore    int       `json:"opponentScore"`
+	Outcome          string    `json:"outcome"`
+}
+
+type PlayerProfile struct {
+	Player  PublicPlayer         `json:"player"`
+	Summary PlayerStatsSummary   `json:"summary"`
+	Recent  []PlayerMatchHistory `json:"recentMatches"`
+}
+
+type PlayerSeriesContext struct {
+	Event  Event
+	Series Series
+	TeamA  Team
+	TeamB  Team
+}
+
+func BuildPlayerProfile(player Player, matches []PlayerSeriesContext, recentLimit int) PlayerProfile {
+	profile := PlayerProfile{
+		Player: PublicPlayer{
+			ID: player.ID, DisplayName: player.DisplayName, BattleTag: player.BattleTag,
+			Ratings: player.Ratings, IsGuest: player.AccountID == "",
+		},
+		Recent: []PlayerMatchHistory{},
+	}
+	for _, match := range matches {
+		if match.Event.State != Completed || match.Series.Phase != SeriesComplete || match.Series.WinnerTeamID == "" {
+			continue
+		}
+		own, opponent, ownIsA := teamContaining(match.TeamA, player.ID), match.TeamB, true
+		if own.ID == "" {
+			own, opponent, ownIsA = teamContaining(match.TeamB, player.ID), match.TeamA, false
+		}
+		if own.ID == "" || opponent.ID == "" {
+			continue
+		}
+		ownScore, opponentScore, mapsWon, mapsLost, mapsDrawn := scoreEffectiveResults(match.Series, ownIsA)
+		profile.Summary.SeriesPlayed++
+		profile.Summary.MapsPlayed += mapsWon + mapsLost + mapsDrawn
+		profile.Summary.MapsWon += mapsWon
+		profile.Summary.MapsLost += mapsLost
+		profile.Summary.MapsDrawn += mapsDrawn
+		outcome := "loss"
+		if match.Series.WinnerTeamID == own.ID {
+			outcome = "win"
+			profile.Summary.SeriesWon++
+		} else {
+			profile.Summary.SeriesLost++
+		}
+		profile.Recent = append(profile.Recent, PlayerMatchHistory{
+			SeriesID: match.Series.ID, EventID: match.Event.ID, EventName: match.Event.Name, EventDate: match.Event.StartsAt,
+			OwnTeamID: own.ID, OwnTeamName: own.Name, OpponentTeamID: opponent.ID, OpponentTeamName: opponent.Name,
+			OwnScore: ownScore, OpponentScore: opponentScore, Outcome: outcome,
+		})
+	}
+	if profile.Summary.SeriesPlayed > 0 {
+		profile.Summary.WinRate = float64(profile.Summary.SeriesWon) / float64(profile.Summary.SeriesPlayed)
+	}
+	sort.SliceStable(profile.Recent, func(i, j int) bool {
+		if profile.Recent[i].EventDate.Equal(profile.Recent[j].EventDate) {
+			return profile.Recent[i].SeriesID > profile.Recent[j].SeriesID
+		}
+		return profile.Recent[i].EventDate.After(profile.Recent[j].EventDate)
+	})
+	if recentLimit >= 0 && len(profile.Recent) > recentLimit {
+		profile.Recent = profile.Recent[:recentLimit]
+	}
+	return profile
+}
+
+func teamContaining(team Team, playerID string) Team {
+	for _, slot := range team.Slots {
+		if slot.PlayerID == playerID {
+			return team
+		}
+	}
+	return Team{}
+}
+
+func scoreEffectiveResults(series Series, ownIsA bool) (ownScore, opponentScore, won, lost, drawn int) {
+	superseded := make(map[int]bool)
+	for _, result := range series.Results {
+		if result.CorrectionOf > 0 {
+			superseded[result.CorrectionOf] = true
+		}
+	}
+	for index, result := range series.Results {
+		if superseded[index+1] {
+			continue
+		}
+		switch result.Outcome {
+		case Draw:
+			drawn++
+		case TeamAWin:
+			if ownIsA {
+				ownScore, won = ownScore+1, won+1
+			} else {
+				opponentScore, lost = opponentScore+1, lost+1
+			}
+		case TeamBWin:
+			if ownIsA {
+				opponentScore, lost = opponentScore+1, lost+1
+			} else {
+				ownScore, won = ownScore+1, won+1
+			}
+		}
+	}
+	return ownScore, opponentScore, won, lost, drawn
+}
+
+type CommunitySettings struct {
+	DiscordInviteURL string    `json:"discordInviteUrl"`
+	UpdatedAt        time.Time `json:"updatedAt"`
+	UpdatedBy        string    `json:"updatedBy"`
+}
+
+func (settings *CommunitySettings) Validate() error {
+	settings.DiscordInviteURL = strings.TrimSpace(settings.DiscordInviteURL)
+	if settings.DiscordInviteURL == "" {
+		return nil
+	}
+	if !strings.HasPrefix(settings.DiscordInviteURL, "https://discord.gg/") &&
+		!strings.HasPrefix(settings.DiscordInviteURL, "https://discord.com/invite/") {
+		return ErrInvalid
+	}
+	code := strings.TrimPrefix(settings.DiscordInviteURL, "https://discord.gg/")
+	code = strings.TrimPrefix(code, "https://discord.com/invite/")
+	if code == "" || strings.ContainsAny(code, "/?# \t\r\n") {
+		return ErrInvalid
+	}
+	return nil
+}