AskaEth
877ff15823
## 算分正确性（6 份只读审查 → 收敛成 5 个病根，均先复现失败再修） - 「人工名次」与「自动名次回写」互斥：原来同一份成绩**发布两次分数不同** （团体报名项 dual 通道 10/8/6 → 25/18/14），现在连发多次逐字节一致 - 删小项时在同一事务作废旧流水并推榜：原来分数**永久残留**在总榜、任何重算都打不到 - 规则包导入整体事务化：原来中途失败会清空名次表且补不回（奖牌全丢）； 另加守卫「compare=none 的小项不得配 basis=result/aggregate」 - 末位归零只抹真正落在末位的那一档：原来跨末位的并列组会被整组抹 0 （7 人三人并列第 5 时第 5、6 名的分也一起没了） - 模板「分值表档位超出录取名次」现在拒绝保存：原来静默截断成 0 分 ## 现场反馈（主人实测报的） - 已发布成绩可改：行内「修改本条」+ 成绩格/状态格可点（退回草稿→改→重新发布本组）， 与「作废」语义分开；取消路径不产生任何副作用 - 单位积分明细补「运动员 / 来源」列，并显示「已修订 ×N（时间·原因）」： 管理端、大屏覆盖层、xlsx 备注列三处同源 - 单位奖牌榜改为按奖牌独立排名（金→银→铜→单位编码），与积分榜解耦 - 历史孤儿积分流水清理（迁移 0022，只动 result/record_bonus，人工调整分不受影响） ## 新功能 - 团体项目聚合口径二选一：平均（默认）/ 总和（迁移 0023，通道编辑器可切） ## 安装器 - 自绘五页安装界面：无边框、自绘标题栏、DPI 自适应（4K@200% 实测）、 安装/卸载逻辑复用 electron-builder 宏不变；默认「为所有用户安装」并自动放行防火墙 19540 - 构建期校验：安装器素材里的版本号必须与 VERSION 一致，否则构建失败 自检：服务端 14 包 ×2 / 前端 vue-tsc + build + 742 例 ×2 / Console 20 文件 + 68 例 ×2，全绿。 端到端对拍：修前 vs 修后，纯团体 / 双计 / 普通个人三形态**逐字节一致**，仅出 bug 的双通道形态按要求改变。
479 lines
14 KiB
Go
479 lines
14 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}
|
||
)
|
||
|
||
// 单位奖牌榜的排序口径（主人 2026-09-13 拍板）：金牌 → 银牌 → 铜牌 → 单位编码。
|
||
//
|
||
// 它**故意不读** StandingsInput.TieBreak：那套键是给总积分榜与个人榜的，
|
||
// 规则包里写的 `points,gold,...` 一进来，奖牌榜就又变回"总分优先"，
|
||
// 会出现"金牌 6 枚的单位排在金牌 2 枚的后面"（06 报告 P1④）。
|
||
var defaultMedalTieBreak = []string{TieBreakGold, TieBreakSilver, TieBreakBronze, TieBreakTeamCode}
|
||
|
||
// StandingsInput 是排名聚合的输入：流水 + 名次明细 + 单位/运动员基础信息。
|
||
type StandingsInput struct {
|
||
Teams []Team
|
||
Athletes []Athlete
|
||
Ledger []LedgerEntry
|
||
Ranked []RankedResult
|
||
// TieBreak 是排序键顺序（如 points/gold/silver/bronze/teamCode/name）；
|
||
// 空表示用默认口径。配置里的键优先，其余按默认顺序补齐，保证结果全序。
|
||
// **只作用于总积分榜与个人榜**：单位奖牌榜固定按金→银→铜→单位编码排（defaultMedalTieBreak）。
|
||
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
|
||
}
|
||
}
|
||
|
||
// medalEligible 是奖牌入选判据（devdocs 17 §4.5）：小项结算奖牌、通道是奖牌通道、
|
||
// 名次在前三，三者同时成立才计入。三个开关随 RankedResult 携带，榜单不必回查库。
|
||
func medalEligible(rr RankedResult) bool {
|
||
return rr.AwardMedals && rr.CountToMedals && rankMedal(rr.Rank) != 0
|
||
}
|
||
|
||
// BuildTeamStandings 生成总积分榜。
|
||
// 总分 = Σ(仅记单位的流水) + 系数 × Σ(记到个人的流水)；排序按 in.TieBreak，缺省为总分 → 金 → 银 → 铜 → 单位编码。
|
||
func BuildTeamStandings(in StandingsInput) []StandingsRow {
|
||
rows := buildTeamRows(in)
|
||
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
|
||
}
|
||
|
||
// buildTeamRows 汇总出「每个单位一行」的原始数据（含兜底补行），不排序、不填名次。
|
||
//
|
||
// 单位总分榜与单位奖牌榜的行集合必须完全一致（同一批单位、同样兜底），
|
||
// 差别只在排序与名次；两条路都从这里出行，避免哪天只给一个榜补了兜底行。
|
||
func buildTeamRows(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))
|
||
}
|
||
}
|
||
return rows
|
||
}
|
||
|
||
// BuildMedalStandings 生成单位奖牌榜。
|
||
//
|
||
// 行集合与总积分榜相同（同一份输入、同一套兜底），但**名次与顺序自成一套**：
|
||
// 金 → 银 → 铜 → 单位编码，与总分无关（主人 2026-09-13 拍板）。
|
||
// 因此绝不能复用总积分榜的 Rank——那正是「金牌多的排在金牌少的后面」的来源。
|
||
func BuildMedalStandings(in StandingsInput) []MedalRow {
|
||
teamRows := buildTeamRows(in)
|
||
out := make([]MedalRow, 0, len(teamRows))
|
||
for _, r := range teamRows {
|
||
out = append(out, MedalRow{
|
||
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,
|
||
})
|
||
}
|
||
sort.SliceStable(out, func(i, j int) bool { return lessMedalRow(out[i], out[j]) })
|
||
for i := range out {
|
||
out[i].Rank = i + 1
|
||
}
|
||
return out
|
||
}
|
||
|
||
// lessMedalRow 是单位奖牌榜的排序：金 DESC → 银 DESC → 铜 DESC → 单位编码 ASC。
|
||
// 只用 defaultMedalTieBreak 这几个键（不掺 StandingsInput.TieBreak），最后用单位 ID 兜底，
|
||
// 保证任意两行都有确定先后（结果全序）。
|
||
func lessMedalRow(a, b MedalRow) bool {
|
||
for _, key := range defaultMedalTieBreak {
|
||
switch key {
|
||
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
|
||
}
|
||
}
|
||
}
|
||
return a.TeamID < b.TeamID
|
||
}
|
||
|
||
// 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,
|
||
}
|
||
}
|
||
|
||
// channelBefore 是计分通道的优先级比较（口径固定，必须确定性）：
|
||
// 个人通道优先于团体通道；同为个人/团体时取通道 id 小者。
|
||
// 奖牌去重与破纪录口径共用这套优先级，保证同一份输入每次选出同一个通道。
|
||
func channelBefore(scopeA Scope, idA int64, scopeB Scope, idB int64) bool {
|
||
if scopeA != scopeB {
|
||
return scopeA == ScopeAthlete
|
||
}
|
||
return idA < idB
|
||
}
|
||
|
||
// medalKey 是奖牌去重键：同一报名项在同一小项、同一组别只记一枚奖牌。
|
||
// 聚合通道不对应单条报名项（EntryID=0），改用名次主体（个人/单位）去重。
|
||
type medalKey struct {
|
||
eventID int64
|
||
categoryID int64
|
||
entryID int64
|
||
scope Scope
|
||
subject int64
|
||
unique int // 退化数据（EntryID 与主体都为空）没有可识别身份，按输入顺序各占一个键
|
||
}
|
||
|
||
// medalKeyOf 计算一条名次明细的去重键；index 用于给无法识别主体的退化数据兜底。
|
||
func medalKeyOf(rr RankedResult, index int) medalKey {
|
||
k := medalKey{eventID: rr.EventID, categoryID: rr.CategoryID, entryID: rr.EntryID}
|
||
if k.entryID != 0 {
|
||
return k
|
||
}
|
||
k.scope = rr.Scope
|
||
if rr.Scope == ScopeAthlete {
|
||
k.subject = rr.AthleteID
|
||
} else {
|
||
k.subject = rr.TeamID
|
||
}
|
||
if k.subject == 0 {
|
||
k.unique = index + 1
|
||
}
|
||
return k
|
||
}
|
||
|
||
// pickMedalChannels 先按奖牌入选判据过滤，再把按通道展开的名次明细去重成「每个主体一条」：
|
||
// 只保留优先级最高的通道名次（个人通道优先），否则双通道项目一条成绩会拿两枚奖牌。
|
||
func pickMedalChannels(ranked []RankedResult, excludeTeam bool) []RankedResult {
|
||
best := make(map[medalKey]RankedResult, len(ranked))
|
||
order := make([]medalKey, 0, len(ranked))
|
||
for i, rr := range ranked {
|
||
if !medalEligible(rr) {
|
||
continue
|
||
}
|
||
if excludeTeam && rr.Scope == ScopeTeam {
|
||
continue
|
||
}
|
||
k := medalKeyOf(rr, i)
|
||
cur, ok := best[k]
|
||
if !ok {
|
||
best[k] = rr
|
||
order = append(order, k)
|
||
continue
|
||
}
|
||
if channelBefore(rr.Scope, rr.ChannelID, cur.Scope, cur.ChannelID) {
|
||
best[k] = rr
|
||
}
|
||
}
|
||
out := make([]RankedResult, 0, len(order))
|
||
for _, k := range order {
|
||
out = append(out, best[k])
|
||
}
|
||
return out
|
||
}
|
||
|
||
// teamMedals 统计单位奖牌榜。按 Shares 逐份额记牌：当前只有「主单位独占 100%」一种口径，
|
||
// 将来若支持联队拆分，每个成员单位都会各记一枚。
|
||
//
|
||
// 两层开关（devdocs 17 §4.5）：
|
||
// - 粗粒度总闸 StandingsInput.ExcludeTeamEventMedals：为 true 时团体项目的奖牌一律不进单位榜；
|
||
// - 通道开关 count_to_team_medals：scope=athlete 的通道置 false 时，它的个人奖牌不进单位榜。
|
||
//
|
||
// 两者是「与」的关系；scope=team 的奖牌本来就记在单位头上，不受通道开关影响。
|
||
func teamMedals(in StandingsInput) map[int64]medalTally {
|
||
out := make(map[int64]medalTally)
|
||
for _, rr := range pickMedalChannels(in.Ranked, in.ExcludeTeamEventMedals) {
|
||
if rr.Scope != ScopeTeam && !rr.CountToTeamMedals {
|
||
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）的奖牌；
|
||
// 通道的 count_to_team_medals 与个人榜无关，只决定这枚奖牌算不算进单位榜。
|
||
func athleteMedals(in StandingsInput) map[int64]medalTally {
|
||
out := make(map[int64]medalTally)
|
||
for _, rr := range pickMedalChannels(in.Ranked, false) {
|
||
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
|
||
}
|