348 lines
8.7 KiB
Go
348 lines
8.7 KiB
Go
package domain
|
|
|
|
import "sort"
|
|
|
|
// 榜单排序键，取值与规则包 standings.tieBreak 一致。
|
|
// 定义在 domain 是为了让 rules 包复用同一套键名，避免两边各写一份常量。
|
|
const (
|
|
TieBreakPoints = "points"
|
|
TieBreakGold = "gold"
|
|
TieBreakSilver = "silver"
|
|
TieBreakBronze = "bronze"
|
|
TieBreakTeamCode = "teamCode"
|
|
TieBreakName = "name"
|
|
)
|
|
|
|
// TieBreak 未配置时的口径，与 devdocs 02 §5.2 一致。
|
|
var (
|
|
defaultTeamTieBreak = []string{TieBreakPoints, TieBreakGold, TieBreakSilver, TieBreakBronze, TieBreakTeamCode}
|
|
defaultAthleteTieBreak = []string{TieBreakPoints, TieBreakGold, TieBreakSilver, TieBreakBronze, TieBreakName}
|
|
)
|
|
|
|
// StandingsInput 是排名聚合的输入：流水 + 名次明细 + 单位/运动员基础信息。
|
|
type StandingsInput struct {
|
|
Teams []Team
|
|
Athletes []Athlete
|
|
Ledger []LedgerEntry
|
|
Ranked []RankedResult
|
|
// TieBreak 是排序键顺序（如 points/gold/silver/bronze/teamCode/name）；
|
|
// 空表示用默认口径。配置里的键优先，其余按默认顺序补齐，保证结果全序。
|
|
TieBreak []string
|
|
// IndividualToTeamWeight 个人积分折算进单位总分的系数；<=0 时按 1 处理。
|
|
IndividualToTeamWeight float64
|
|
// ExcludeTeamEventMedals 为 true 时团体奖牌榜不计团体项目奖牌；默认计入。
|
|
ExcludeTeamEventMedals bool
|
|
}
|
|
|
|
type medalTally struct {
|
|
gold, silver, bronze int
|
|
}
|
|
|
|
// rankMedal 把名次映射成奖牌：1 金 / 2 银 / 3 铜，其余无名次。
|
|
func rankMedal(rank int) int {
|
|
switch rank {
|
|
case 1:
|
|
return 1
|
|
case 2:
|
|
return 2
|
|
case 3:
|
|
return 3
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// BuildTeamStandings 生成总积分榜。
|
|
// 总分 = Σ(仅记单位的流水) + 系数 × Σ(记到个人的流水)；排序按 in.TieBreak，缺省为总分 → 金 → 银 → 铜 → 单位编码。
|
|
func BuildTeamStandings(in StandingsInput) []StandingsRow {
|
|
weight := effectiveWeight(in.IndividualToTeamWeight)
|
|
sums := SumByTeam(in.Ledger, weight)
|
|
medals := teamMedals(in)
|
|
|
|
rows := make([]StandingsRow, 0, len(in.Teams))
|
|
seen := make(map[int64]bool, len(in.Teams))
|
|
for _, t := range in.Teams {
|
|
if seen[t.ID] {
|
|
continue
|
|
}
|
|
seen[t.ID] = true
|
|
rows = append(rows, buildTeamRow(t, sums[t.ID], medals[t.ID]))
|
|
}
|
|
// 兜底：流水/奖牌里出现但单位表没提供的单位也要上榜，否则分数会被静默吞掉。
|
|
for id := range sums {
|
|
if !seen[id] {
|
|
seen[id] = true
|
|
rows = append(rows, buildTeamRow(Team{ID: id}, sums[id], medals[id]))
|
|
}
|
|
}
|
|
for id, m := range medals {
|
|
if !seen[id] {
|
|
seen[id] = true
|
|
rows = append(rows, buildTeamRow(Team{ID: id}, sums[id], m))
|
|
}
|
|
}
|
|
|
|
sort.SliceStable(rows, func(i, j int) bool { return lessTeamRow(rows[i], rows[j], in.TieBreak) })
|
|
for i := range rows {
|
|
rows[i].Rank = i + 1
|
|
}
|
|
return rows
|
|
}
|
|
|
|
// BuildMedalStandings 生成团体奖牌榜。
|
|
// 排序口径与总积分榜一致（总分优先），只是列不同，保证两块榜的单位顺序不会打架。
|
|
func BuildMedalStandings(in StandingsInput) []MedalRow {
|
|
teamRows := BuildTeamStandings(in)
|
|
out := make([]MedalRow, len(teamRows))
|
|
for i, r := range teamRows {
|
|
out[i] = MedalRow{
|
|
Rank: r.Rank,
|
|
TeamID: r.TeamID,
|
|
Code: r.Code,
|
|
Name: r.Name,
|
|
ShortName: r.ShortName,
|
|
Points: r.Points,
|
|
Gold: r.Gold,
|
|
Silver: r.Silver,
|
|
Bronze: r.Bronze,
|
|
Total: r.Gold + r.Silver + r.Bronze,
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// BuildAthleteStandings 生成个人积分奖牌榜。
|
|
// 排序按 in.TieBreak，缺省为总分 → 金 → 银 → 铜 → 姓名；个人榜的奖牌只统计个人项目（团体项目奖牌归团体榜）。
|
|
func BuildAthleteStandings(in StandingsInput) []AthleteStandingsRow {
|
|
points := SumByAthlete(in.Ledger)
|
|
medals := athleteMedals(in)
|
|
|
|
names := make(map[int64]string, len(in.Athletes))
|
|
teams := make(map[int64]int64, len(in.Athletes))
|
|
for _, a := range in.Athletes {
|
|
names[a.ID] = a.Name
|
|
teams[a.ID] = a.TeamID
|
|
}
|
|
for _, rr := range in.Ranked {
|
|
if rr.AthleteID == 0 {
|
|
continue
|
|
}
|
|
if names[rr.AthleteID] == "" {
|
|
names[rr.AthleteID] = rr.AthleteName
|
|
}
|
|
if _, ok := teams[rr.AthleteID]; !ok {
|
|
teams[rr.AthleteID] = rr.TeamID
|
|
}
|
|
}
|
|
|
|
teamByID := make(map[int64]Team, len(in.Teams))
|
|
for _, t := range in.Teams {
|
|
teamByID[t.ID] = t
|
|
}
|
|
|
|
seen := make(map[int64]bool, len(points)+len(medals))
|
|
ids := make([]int64, 0, len(points)+len(medals))
|
|
add := func(id int64) {
|
|
if id == 0 || seen[id] {
|
|
return
|
|
}
|
|
seen[id] = true
|
|
ids = append(ids, id)
|
|
}
|
|
for id := range points {
|
|
add(id)
|
|
}
|
|
for id := range medals {
|
|
add(id)
|
|
}
|
|
|
|
rows := make([]AthleteStandingsRow, 0, len(ids))
|
|
for _, id := range ids {
|
|
t := teamByID[teams[id]]
|
|
m := medals[id]
|
|
rows = append(rows, AthleteStandingsRow{
|
|
AthleteID: id,
|
|
Name: names[id],
|
|
TeamID: teams[id],
|
|
TeamCode: t.Code,
|
|
TeamName: t.Name,
|
|
Points: points[id],
|
|
Gold: m.gold,
|
|
Silver: m.silver,
|
|
Bronze: m.bronze,
|
|
Medals: m.gold + m.silver + m.bronze,
|
|
})
|
|
}
|
|
|
|
sort.SliceStable(rows, func(i, j int) bool { return lessAthleteRow(rows[i], rows[j], in.TieBreak) })
|
|
for i := range rows {
|
|
rows[i].Rank = i + 1
|
|
}
|
|
return rows
|
|
}
|
|
|
|
func effectiveWeight(weight float64) float64 {
|
|
if weight <= 0 {
|
|
return 1
|
|
}
|
|
return weight
|
|
}
|
|
|
|
func buildTeamRow(t Team, p TeamPoints, m medalTally) StandingsRow {
|
|
return StandingsRow{
|
|
TeamID: t.ID,
|
|
Code: t.Code,
|
|
Name: t.Name,
|
|
ShortName: t.ShortName,
|
|
Points: p.Total,
|
|
TeamOnlyPoints: p.TeamOnly,
|
|
IndividualPoints: p.Individual,
|
|
Gold: m.gold,
|
|
Silver: m.silver,
|
|
Bronze: m.bronze,
|
|
Medals: m.gold + m.silver + m.bronze,
|
|
}
|
|
}
|
|
|
|
// teamMedals 统计团体奖牌榜。联队拆分时两个单位各记一枚：
|
|
// 联合组队拿到的名次对每个成员单位都是「本单位取得的名次」。
|
|
func teamMedals(in StandingsInput) map[int64]medalTally {
|
|
out := make(map[int64]medalTally)
|
|
for _, rr := range in.Ranked {
|
|
if rr.Scope == ScopeTeam && in.ExcludeTeamEventMedals {
|
|
continue
|
|
}
|
|
medal := rankMedal(rr.Rank)
|
|
if medal == 0 {
|
|
continue
|
|
}
|
|
for _, s := range rr.Shares {
|
|
t := out[s.TeamID]
|
|
switch medal {
|
|
case 1:
|
|
t.gold++
|
|
case 2:
|
|
t.silver++
|
|
case 3:
|
|
t.bronze++
|
|
}
|
|
out[s.TeamID] = t
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// athleteMedals 只统计个人项目（scope=athlete）的奖牌。
|
|
func athleteMedals(in StandingsInput) map[int64]medalTally {
|
|
out := make(map[int64]medalTally)
|
|
for _, rr := range in.Ranked {
|
|
if rr.Scope != ScopeAthlete || rr.AthleteID == 0 {
|
|
continue
|
|
}
|
|
medal := rankMedal(rr.Rank)
|
|
if medal == 0 {
|
|
continue
|
|
}
|
|
t := out[rr.AthleteID]
|
|
switch medal {
|
|
case 1:
|
|
t.gold++
|
|
case 2:
|
|
t.silver++
|
|
case 3:
|
|
t.bronze++
|
|
}
|
|
out[rr.AthleteID] = t
|
|
}
|
|
return out
|
|
}
|
|
|
|
// tieBreakKeys 把配置的排序键展开成实际比较顺序：配置优先，缺失的默认键补在后面，
|
|
// 保证两行在所有键上都相等时仍能由调用方的 ID 兜底分出先后。
|
|
func tieBreakKeys(cfg, def []string) []string {
|
|
if len(cfg) == 0 {
|
|
return def
|
|
}
|
|
out := make([]string, 0, len(cfg)+len(def))
|
|
seen := make(map[string]bool, len(cfg)+len(def))
|
|
for _, key := range cfg {
|
|
if seen[key] {
|
|
continue
|
|
}
|
|
seen[key] = true
|
|
out = append(out, key)
|
|
}
|
|
for _, key := range def {
|
|
if seen[key] {
|
|
continue
|
|
}
|
|
seen[key] = true
|
|
out = append(out, key)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func lessTeamRow(a, b StandingsRow, tieBreak []string) bool {
|
|
for _, key := range tieBreakKeys(tieBreak, defaultTeamTieBreak) {
|
|
switch key {
|
|
case TieBreakPoints:
|
|
if !nearlyEqual(a.Points, b.Points) {
|
|
return a.Points > b.Points
|
|
}
|
|
case TieBreakGold:
|
|
if a.Gold != b.Gold {
|
|
return a.Gold > b.Gold
|
|
}
|
|
case TieBreakSilver:
|
|
if a.Silver != b.Silver {
|
|
return a.Silver > b.Silver
|
|
}
|
|
case TieBreakBronze:
|
|
if a.Bronze != b.Bronze {
|
|
return a.Bronze > b.Bronze
|
|
}
|
|
case TieBreakTeamCode:
|
|
if a.Code != b.Code {
|
|
return a.Code < b.Code
|
|
}
|
|
case TieBreakName:
|
|
if a.Name != b.Name {
|
|
return a.Name < b.Name
|
|
}
|
|
}
|
|
}
|
|
return a.TeamID < b.TeamID
|
|
}
|
|
|
|
func lessAthleteRow(a, b AthleteStandingsRow, tieBreak []string) bool {
|
|
for _, key := range tieBreakKeys(tieBreak, defaultAthleteTieBreak) {
|
|
switch key {
|
|
case TieBreakPoints:
|
|
if !nearlyEqual(a.Points, b.Points) {
|
|
return a.Points > b.Points
|
|
}
|
|
case TieBreakGold:
|
|
if a.Gold != b.Gold {
|
|
return a.Gold > b.Gold
|
|
}
|
|
case TieBreakSilver:
|
|
if a.Silver != b.Silver {
|
|
return a.Silver > b.Silver
|
|
}
|
|
case TieBreakBronze:
|
|
if a.Bronze != b.Bronze {
|
|
return a.Bronze > b.Bronze
|
|
}
|
|
case TieBreakTeamCode:
|
|
if a.TeamCode != b.TeamCode {
|
|
return a.TeamCode < b.TeamCode
|
|
}
|
|
case TieBreakName:
|
|
if a.Name != b.Name {
|
|
return a.Name < b.Name
|
|
}
|
|
}
|
|
}
|
|
return a.AthleteID < b.AthleteID
|
|
}
|