feat(joint-team): 联队 + 份额分成 —— 迁移 0024、引擎按份额拆、导出 / 大屏 / 录入三路打通；版本 dev_0.5.3
## 需求
现场 6 项球类比赛里，有两个单位因参赛人数不足**合并成一个单位参赛**。
做法不是新建「联队单位」（那样榜单会多出第 8 个单位，且分和奖牌分不到原单位头上），
而是**一条报名挂多个单位、按份额拆**。
## 拍板口径
- 份额**可配、默认均分**
- 积分**平均拆、接受 .5**（团体第 1 名 15 分 → 两个单位各 7.5 分）
- 奖牌**各记一枚**（两个单位各 1 枚完整金牌，不是各 0.5 枚）
- 显示上把联队名字写全（形如 `第一分公司+第二分公司联队`），成员单位的 logo 都放
- 导入表里单位编码写 `A+B`
## 一、核心层（数据模型 + 引擎 + 存储 + 报名写入 + 导入解析）
- 迁移 `0024_entry_team_shares.sql`：新建 `entry_team_shares(entry_id, team_id, points_share,
medal_share, sort_order)`。**两个口径分开表达**是刻意的——积分要拆成小数（7.5）、奖牌要整枚
各记，用一个数表达就会把「7.5 分」和「半枚金牌」绑在一起，奖牌榜立刻错。
`entries.team_id` 保留为**主单位**；老数据 `INSERT OR IGNORE` 回填成「主单位独占 100%」。
- 引擎：`ResolveShares`（引擎与读侧共用）、`splitSharePoints`（按权重归一、**末位吞余数**，
各份之和恒等于原来那一份）、`TeamShare.Medal`（缺省整枚）。积分按权重拆，奖牌每个份额各记整枚。
- 报名写入：`PUT /api/entries/{id}/team-shares`（recorder 及以上，保存后当场重算该小项组别并推榜）。
- 导入：`team_code` 支持 `A+B`（主单位 = 加号左边，均分，奖牌各整枚）；非法形态
（`A+` / `+B` / `A++B` / `A+A` / 成员 >5 / 单位不存在）**行级拦下、不落库**，给人话报错。
## 二、导出与导入模板
- 11 份导出件：联队写全成员单位（`第一分公司+第二分公司联队`），并注明**分拆给了哪几家、各多少**
（份额占比 + 各单位实得积分，取自按份额拆完的流水）。
- 单位奖牌明细：奖牌格写「金牌（联队 …，各单位各记 1 枚）」；含联队时副标题说明
「各单位奖牌数之和会大于实际颁发数」——这是口径 3 的必然结果，**不是 bug**。
- 按单位筛选导出把成员单位一起算上（否则 B 单位导自己的名单会看不到自己参加的那场联队比赛）。
- 分工作表模板：`A+B` 写法挂在「单位编码」表头的**单元格批注 + 输入提示**（中英各一份）；
**表头文字、列序、12 列、工作表命名一个字未动**（动了模板就导不回去）。
## 三、前端与大屏
- 录入页 / 复核页「单位」列：联队显示 `联队 第一分公司 67%（权重 2） 第二分公司 33%`，
点该格打开「成员单位与份额」弹窗（加/删成员、改权重、主单位徽标、实时比例预览）。
**普通报名（单单位）的文案、元素、类名一字未动**，只多了一个 `@click` 入口与悬停提示。
- 大屏：分项成绩 / 实时赛况单位列显示联队全名并**放上两个单位的 logo**（单位列宽按该行的
logo 数留位）；底栏同理。
## 四、验证（都留了证据）
- **老数据逐字节不变**（改算分引擎的硬门槛）：引擎层 golden `a2aa1c97…`、接口层 golden
`aa6cea37…`，两个哈希由主会话**在修前树上亲手重跑确认**；导出层另有 11 份导出件逐行对拍，
差异 **0 处**。
- 前端 773 → **809 例**全绿（旧用例一行未改）；服务端 14 包两轮全绿；Console 68 例全绿。
- 真机联调：录入页份额弹窗、大屏两个 logo、奖牌榜 A/B 各 1 金、写路径（移除成员 → 保存 → 200）。
## 五、版本
`dev_0.5.2` → **`dev_0.5.3`**（本批含数据迁移 0024 + 新功能，必须与上一包区分开）；
安装器素材重生成（版本号烙在位图里，实测只有 `brand.bmp` 的 1x/2x 两张变化，其余 92 张逐字节未变）。
This commit is contained in:
AskaEth committed
1 parent
b631418a85
commit
830a4dbdb7
61 files changed
+5649
-121
No files matched your search
@@ -82,6 +82,8 @@ type participant struct {
|
||||
status ResultStatus
|
||||
entryStatus EntryStatus
|
||||
state ResultState
|
||||
// shares 是联队份额（多个单位共享一条成绩）；留空 = 主单位独占 100%。
|
||||
shares []TeamShare
|
||||
}
|
||||
|
||||
func fixture(ps []participant) ([]Entry, []Result) {
|
||||
@@ -91,7 +93,7 @@ func fixture(ps []participant) ([]Entry, []Result) {
|
||||
entries = append(entries, Entry{
|
||||
ID: p.entryID, EventID: 1, CategoryID: 1, TeamID: p.teamID,
|
||||
AthleteID: p.athleteID, AthleteName: p.name,
|
||||
Status: p.entryStatus,
|
||||
Status: p.entryStatus, TeamShares: p.shares,
|
||||
})
|
||||
state := p.state
|
||||
if state == "" {
|
||||
|
||||
@@ -0,0 +1,377 @@
|
||||
package domain
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
// 本文件钉住「联队 + 份额分成」的算分口径（devdocs/19 第三节的五条拍板）。
|
||||
//
|
||||
// 两个口径必须分开表达，测试也分成两组：
|
||||
// - 积分按份额拆：团体第 1 名 15 分 → 联队的两个单位各 7.5 分（允许出现小数）；
|
||||
// - 奖牌整枚各记：同一个金牌 → 两个单位**各记 1 枚**（不是各 0.5 枚）。
|
||||
//
|
||||
// 另外单钉一处最容易错的口径：份额与 count_to_team / count_to_medals 两个通道开关叠加。
|
||||
// 单位总分公式是 `Σ仅记单位的流水 + 全局系数 × Σ(记到个人且 count_to_team=1 的流水)`，
|
||||
// 份额只改「这一份分记在哪个单位头上」，两个开关仍然按通道整体决定这条流水算不算数。
|
||||
|
||||
// jointShares 构造联队份额：两个单位均分（默认口径），奖牌各记整枚。
|
||||
func jointShares(teamIDs ...int64) []TeamShare {
|
||||
out := make([]TeamShare, 0, len(teamIDs))
|
||||
for _, id := range teamIDs {
|
||||
out = append(out, TeamShare{TeamID: id})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// weightedShares 构造按给定权重拆分的份额（奖牌缺省 = 整枚各记）。
|
||||
func weightedShares(pairs ...any) []TeamShare {
|
||||
out := make([]TeamShare, 0, len(pairs)/2)
|
||||
for i := 0; i+1 < len(pairs); i += 2 {
|
||||
out = append(out, TeamShare{TeamID: pairs[i].(int64), Weight: pairs[i+1].(float64)})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// medalOf 取单位奖牌榜上某单位的金银铜。
|
||||
func medalOf(rows []MedalRow, teamID int64) (gold, silver, bronze int) {
|
||||
for _, r := range rows {
|
||||
if r.TeamID == teamID {
|
||||
return r.Gold, r.Silver, r.Bronze
|
||||
}
|
||||
}
|
||||
return 0, 0, 0
|
||||
}
|
||||
|
||||
// teamMedalRows 用一份「引擎产出」直接算单位奖牌榜。
|
||||
func teamMedalRows(t *testing.T, ledger []LedgerEntry, ranked []RankedResult, teamIDs ...int64) []MedalRow {
|
||||
t.Helper()
|
||||
return BuildMedalStandings(StandingsInput{
|
||||
Teams: testTeams(teamIDs...),
|
||||
Ledger: ledger,
|
||||
Ranked: ranked,
|
||||
})
|
||||
}
|
||||
|
||||
// scoreTeamManualWithEntries 用团体手工名次通道跑一次计分：名次按单位录（联队录在主单位上），
|
||||
// 报名项由调用方给（联队的名次想按份额拆，库里得先有那条联队报名）。
|
||||
func scoreTeamManualWithEntries(t *testing.T, entries []Entry, ranks ...TeamManualRank) EventScore {
|
||||
t.Helper()
|
||||
return mustScore(t, EventScoreInput{
|
||||
Event: teamEvent(1), Category: testCategory(),
|
||||
Channels: []ScoreChannel{teamManualChannel(9)},
|
||||
Profiles: map[int64]ScoringProfile{9: teamTop6()},
|
||||
Entries: entries,
|
||||
TeamRanks: ranks,
|
||||
})
|
||||
}
|
||||
|
||||
// 口径 2：团体第 1 名 15 分，联队的两个单位各 7.5 分（奇数分平均拆，允许 .5）。
|
||||
func TestJointTeamSplitsPointsEvenly(t *testing.T) {
|
||||
// 团体报名项（athlete_id=0）+ 份额 [A,B]，名次录在主单位 A 上。
|
||||
entries, _ := fixture([]participant{{entryID: 1, teamID: 1, shares: jointShares(1, 2)}})
|
||||
es := scoreTeamManualWithEntries(t, entries, TeamManualRank{TeamID: 1, Rank: 1})
|
||||
|
||||
pts := pointsByTeam(es.Ledger)
|
||||
if !nearlyEqual(pts[1], 7.5) || !nearlyEqual(pts[2], 7.5) {
|
||||
t.Fatalf("联队第 1 名应各得 7.5 分，得到 A=%v B=%v（流水：%+v）", pts[1], pts[2], es.Ledger)
|
||||
}
|
||||
// 拆出来的份数之和必须正好等于原来那一份，否则「一个单位改成联队」会悄悄改变总分。
|
||||
if !nearlyEqual(pts[1]+pts[2], 15) {
|
||||
t.Fatalf("两份之和应等于 15，得到 %v", pts[1]+pts[2])
|
||||
}
|
||||
// 每一条份额各是一条流水（各有 team_id），名次本身只有一条。
|
||||
if len(es.Ledger) != 2 {
|
||||
t.Fatalf("应产出 2 条流水（A、B 各一条），得到 %d 条：%+v", len(es.Ledger), es.Ledger)
|
||||
}
|
||||
for _, l := range es.Ledger {
|
||||
if l.AthleteID != 0 {
|
||||
t.Fatalf("团体通道的流水不该挂个人：%+v", l)
|
||||
}
|
||||
}
|
||||
if len(es.Ranked) != 1 || len(es.Ranked[0].Shares) != 2 {
|
||||
t.Fatalf("名次明细应只有一条、带两份份额：%+v", es.Ranked)
|
||||
}
|
||||
}
|
||||
|
||||
// 名次直接录在联队报名项上（成绩录入页填名次，不走按单位录的团体名次）也必须按份额拆。
|
||||
func TestJointTeamSplitsPointsFromEntryRank(t *testing.T) {
|
||||
entries, results := fixture([]participant{{
|
||||
entryID: 1, teamID: 1, shares: jointShares(1, 2), rank: 1, noValue: true,
|
||||
}})
|
||||
es := mustScore(t, EventScoreInput{
|
||||
Event: teamEvent(1), Category: testCategory(),
|
||||
Channels: []ScoreChannel{teamManualChannel(9)},
|
||||
Profiles: map[int64]ScoringProfile{9: teamTop6()},
|
||||
Entries: entries, Results: results,
|
||||
})
|
||||
pts := pointsByTeam(es.Ledger)
|
||||
if !nearlyEqual(pts[1], 7.5) || !nearlyEqual(pts[2], 7.5) {
|
||||
t.Fatalf("联队报名项上的第 1 名应各得 7.5 分，得到 A=%v B=%v", pts[1], pts[2])
|
||||
}
|
||||
}
|
||||
|
||||
// 口径 3：奖牌整枚各记——联队拿到的金牌，两个单位各记 1 枚完整金牌。
|
||||
func TestJointTeamMedalsAreWholeForEachMember(t *testing.T) {
|
||||
entries, _ := fixture([]participant{{entryID: 1, teamID: 1, shares: jointShares(1, 2)}})
|
||||
es := scoreTeamManualWithEntries(t, entries, TeamManualRank{TeamID: 1, Rank: 1})
|
||||
|
||||
rows := teamMedalRows(t, es.Ledger, es.Ranked, 1, 2, 3)
|
||||
if gold, _, _ := medalOf(rows, 1); gold != 1 {
|
||||
t.Fatalf("主单位 A 应记 1 枚金牌，得到 %d 枚（%+v）", gold, rows)
|
||||
}
|
||||
if gold, _, _ := medalOf(rows, 2); gold != 1 {
|
||||
t.Fatalf("成员单位 B 应记 1 枚金牌（不是 0.5 枚），得到 %d 枚（%+v）", gold, rows)
|
||||
}
|
||||
if gold, _, _ := medalOf(rows, 3); gold != 0 {
|
||||
t.Fatalf("没参赛的单位不该有奖牌，得到 %d 枚", gold)
|
||||
}
|
||||
}
|
||||
|
||||
// 可配权重：2:1 时积分按 2:1 拆，奖牌仍是各 1 枚（两个口径互不影响）。
|
||||
func TestJointTeamWeightsAreConfigurable(t *testing.T) {
|
||||
entries, _ := fixture([]participant{{
|
||||
entryID: 1, teamID: 1, shares: weightedShares(int64(1), 2.0, int64(2), 1.0),
|
||||
}})
|
||||
es := scoreTeamManualWithEntries(t, entries, TeamManualRank{TeamID: 1, Rank: 1})
|
||||
|
||||
pts := pointsByTeam(es.Ledger)
|
||||
if !nearlyEqual(pts[1], 10) || !nearlyEqual(pts[2], 5) {
|
||||
t.Fatalf("2:1 的权重应拆成 10 / 5，得到 A=%v B=%v（流水：%+v）", pts[1], pts[2], es.Ledger)
|
||||
}
|
||||
if !nearlyEqual(pts[1]+pts[2], 15) {
|
||||
t.Fatalf("2:1 拆分后两份之和应仍是 15，得到 %v", pts[1]+pts[2])
|
||||
}
|
||||
rows := teamMedalRows(t, es.Ledger, es.Ranked, 1, 2)
|
||||
if gold, _, _ := medalOf(rows, 2); gold != 1 {
|
||||
t.Fatalf("权重只影响积分，奖牌仍是整枚各记：B 应 1 枚金牌，得到 %d 枚", gold)
|
||||
}
|
||||
}
|
||||
|
||||
// 份额上的 medal 开关：显式关掉时该单位不记这枚奖牌（积分不受影响）。
|
||||
func TestJointTeamMedalCanBeTurnedOffPerMember(t *testing.T) {
|
||||
noMedal := false
|
||||
shares := []TeamShare{{TeamID: 1, Medal: &noMedal}, {TeamID: 2}}
|
||||
entries, _ := fixture([]participant{{entryID: 1, teamID: 1, shares: shares}})
|
||||
es := scoreTeamManualWithEntries(t, entries, TeamManualRank{TeamID: 1, Rank: 1})
|
||||
|
||||
rows := teamMedalRows(t, es.Ledger, es.Ranked, 1, 2)
|
||||
if gold, _, _ := medalOf(rows, 1); gold != 0 {
|
||||
t.Fatalf("显式关掉奖牌的成员单位不该记牌，得到 %d 枚", gold)
|
||||
}
|
||||
if gold, _, _ := medalOf(rows, 2); gold != 1 {
|
||||
t.Fatalf("没关掉的那个单位仍记 1 枚，得到 %d 枚", gold)
|
||||
}
|
||||
pts := pointsByTeam(es.Ledger)
|
||||
if !nearlyEqual(pts[1], 7.5) || !nearlyEqual(pts[2], 7.5) {
|
||||
t.Fatalf("奖牌开关不该影响积分分配，得到 A=%v B=%v", pts[1], pts[2])
|
||||
}
|
||||
}
|
||||
|
||||
// 份额 × 通道开关（count_to_team / count_to_medals）的叠加矩阵。
|
||||
//
|
||||
// 这一处最容易错：份额只改「这一份记在哪个单位头上」，两个开关仍然按通道整体决定
|
||||
// 这条流水/名次算不算数。四种组合都必须能单独说清。
|
||||
func TestJointTeamSharesWithChannelSwitches(t *testing.T) {
|
||||
countToTeam := func(v bool) *bool { return &v }
|
||||
|
||||
t.Run("团体通道 + count_to_team=1：两份都进单位总分", func(t *testing.T) {
|
||||
entries, _ := fixture([]participant{{entryID: 1, teamID: 1, shares: jointShares(1, 2)}})
|
||||
es := scoreTeamManualWithEntries(t, entries, TeamManualRank{TeamID: 1, Rank: 1})
|
||||
sums := SumByTeam(es.Ledger, 1)
|
||||
if !nearlyEqual(sums[1].Total, 7.5) || !nearlyEqual(sums[2].Total, 7.5) {
|
||||
t.Fatalf("两个单位各应得 7.5 分（仅记单位通道），得到 A=%+v B=%+v", sums[1], sums[2])
|
||||
}
|
||||
if !nearlyEqual(sums[1].TeamOnly, 7.5) {
|
||||
t.Fatalf("团体通道的流水应记在「仅记单位」一栏，得到 %+v", sums[1])
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("团体通道 + count_to_team=0：流水照记，但不进任何单位的总分", func(t *testing.T) {
|
||||
ch := teamManualChannel(9)
|
||||
ch.CountToTeam = countToTeam(false)
|
||||
entries, _ := fixture([]participant{{entryID: 1, teamID: 1, shares: jointShares(1, 2)}})
|
||||
es := mustScore(t, EventScoreInput{
|
||||
Event: teamEvent(1), Category: testCategory(),
|
||||
Channels: []ScoreChannel{ch}, Profiles: map[int64]ScoringProfile{9: teamTop6()},
|
||||
Entries: entries, TeamRanks: []TeamManualRank{{TeamID: 1, Rank: 1}},
|
||||
})
|
||||
if len(es.Ledger) != 2 {
|
||||
t.Fatalf("流水要照记（每条份额一条），得到 %d 条", len(es.Ledger))
|
||||
}
|
||||
for _, l := range es.Ledger {
|
||||
if l.CountToTeam {
|
||||
t.Fatalf("通道关掉计入单位总分后，流水上的 count_to_team 应为 false：%+v", l)
|
||||
}
|
||||
}
|
||||
if sums := SumByTeam(es.Ledger, 1); len(sums) != 0 {
|
||||
t.Fatalf("关掉 count_to_team 后不该有任何单位分，得到 %+v", sums)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("个人通道 + count_to_team=1：两份都按个人分进各自单位（乘系数）", func(t *testing.T) {
|
||||
entries, results := fixture([]participant{{
|
||||
entryID: 1, athleteID: 101, teamID: 1, shares: jointShares(1, 2), value: 10,
|
||||
}})
|
||||
es := mustScore(t, EventScoreInput{
|
||||
Event: individualEvent(1), Category: testCategory(),
|
||||
Channels: []ScoreChannel{athleteResultChannel(9)}, Profiles: map[int64]ScoringProfile{9: individualTop6()},
|
||||
Entries: entries, Results: results,
|
||||
})
|
||||
sums := SumByTeam(es.Ledger, 1)
|
||||
if !nearlyEqual(sums[1].Individual, 5) || !nearlyEqual(sums[2].Individual, 5) {
|
||||
t.Fatalf("个人通道的两份应各进各自单位的个人分（各 5），得到 A=%+v B=%+v", sums[1], sums[2])
|
||||
}
|
||||
// 系数只乘一次：单位总分 = 系数 × 个人分，联队不会把这条成绩算两遍。
|
||||
if sums := SumByTeam(es.Ledger, 0.5); !nearlyEqual(sums[1].Total, 2.5) {
|
||||
t.Fatalf("系数 0.5 下 A 的总分应为 2.5，得到 %v", sums[1].Total)
|
||||
}
|
||||
// 个人榜不受份额影响：这两条流水加起来还是原来那 10 分。
|
||||
if ath := SumByAthlete(es.Ledger); !nearlyEqual(ath[101], 10) {
|
||||
t.Fatalf("个人榜上该运动员应仍是 10 分，得到 %v", ath[101])
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("个人通道 + count_to_team=0：只记个人榜，不进任何单位总分", func(t *testing.T) {
|
||||
ch := athleteResultChannel(9)
|
||||
ch.CountToTeam = countToTeam(false)
|
||||
entries, results := fixture([]participant{{
|
||||
entryID: 1, athleteID: 101, teamID: 1, shares: jointShares(1, 2), value: 10,
|
||||
}})
|
||||
es := mustScore(t, EventScoreInput{
|
||||
Event: individualEvent(1), Category: testCategory(),
|
||||
Channels: []ScoreChannel{ch}, Profiles: map[int64]ScoringProfile{9: individualTop6()},
|
||||
Entries: entries, Results: results,
|
||||
})
|
||||
if sums := SumByTeam(es.Ledger, 1); len(sums) != 0 {
|
||||
t.Fatalf("count_to_team=0 的个人通道不该进单位总分，得到 %+v", sums)
|
||||
}
|
||||
if ath := SumByAthlete(es.Ledger); !nearlyEqual(ath[101], 10) {
|
||||
t.Fatalf("个人榜照旧记 10 分，得到 %v", ath[101])
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("count_to_medals=0：不发奖牌（积分照发）", func(t *testing.T) {
|
||||
ch := teamManualChannel(9)
|
||||
no := false
|
||||
ch.CountToMedals = &no
|
||||
entries, _ := fixture([]participant{{entryID: 1, teamID: 1, shares: jointShares(1, 2)}})
|
||||
es := mustScore(t, EventScoreInput{
|
||||
Event: teamEvent(1), Category: testCategory(),
|
||||
Channels: []ScoreChannel{ch}, Profiles: map[int64]ScoringProfile{9: teamTop6()},
|
||||
Entries: entries, TeamRanks: []TeamManualRank{{TeamID: 1, Rank: 1}},
|
||||
})
|
||||
rows := teamMedalRows(t, es.Ledger, es.Ranked, 1, 2)
|
||||
if gold, _, _ := medalOf(rows, 1); gold != 0 {
|
||||
t.Fatalf("关掉奖牌通道后 A 不该有金牌，得到 %d 枚", gold)
|
||||
}
|
||||
if gold, _, _ := medalOf(rows, 2); gold != 0 {
|
||||
t.Fatalf("关掉奖牌通道后 B 不该有金牌，得到 %d 枚", gold)
|
||||
}
|
||||
if pts := pointsByTeam(es.Ledger); !nearlyEqual(pts[1], 7.5) {
|
||||
t.Fatalf("奖牌开关不影响积分：A 应仍是 7.5，得到 %v", pts[1])
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("个人通道 + count_to_team_medals=0：个人榜有牌、单位榜没有", func(t *testing.T) {
|
||||
ch := athleteResultChannel(9)
|
||||
no := false
|
||||
ch.CountToTeamMedals = &no
|
||||
entries, results := fixture([]participant{{
|
||||
entryID: 1, athleteID: 101, teamID: 1, shares: jointShares(1, 2), value: 10,
|
||||
}})
|
||||
es := mustScore(t, EventScoreInput{
|
||||
Event: individualEvent(1), Category: testCategory(),
|
||||
Channels: []ScoreChannel{ch}, Profiles: map[int64]ScoringProfile{9: individualTop6()},
|
||||
Entries: entries, Results: results,
|
||||
})
|
||||
rows := teamMedalRows(t, es.Ledger, es.Ranked, 1, 2)
|
||||
if gold, _, _ := medalOf(rows, 1); gold != 0 {
|
||||
t.Fatalf("个人奖牌不并入单位榜时 A 不该有金牌，得到 %d 枚", gold)
|
||||
}
|
||||
ath := BuildAthleteStandings(StandingsInput{
|
||||
Athletes: []Athlete{{ID: 101, Name: "选手A", TeamID: 1}},
|
||||
Ledger: es.Ledger, Ranked: es.Ranked,
|
||||
})
|
||||
if len(ath) != 1 || ath[0].Gold != 1 {
|
||||
t.Fatalf("个人榜上该运动员仍应有 1 枚金牌，得到 %+v", ath)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// 联队报名不影响普通报名项：同一个小项里既有联队又有单单位时，两边各按自己的份额落分。
|
||||
func TestJointTeamCoexistsWithSingleTeamEntries(t *testing.T) {
|
||||
// 项目按成绩升序排名（individualEvent 的 compare=asc），联队跑得更好，拿第 1 名。
|
||||
entries, results := fixture([]participant{
|
||||
{entryID: 1, teamID: 1, shares: jointShares(1, 2), value: 80},
|
||||
{entryID: 2, teamID: 3, value: 90},
|
||||
})
|
||||
ev := teamEvent(1)
|
||||
es := mustScore(t, EventScoreInput{
|
||||
Event: ev, Category: testCategory(),
|
||||
Channels: []ScoreChannel{{ID: 4, EventID: 1, Scope: ScopeTeam, Basis: BasisResult, ProfileID: 9}},
|
||||
Profiles: map[int64]ScoringProfile{9: teamTop6()},
|
||||
Entries: entries, Results: results,
|
||||
})
|
||||
pts := pointsByTeam(es.Ledger)
|
||||
if !nearlyEqual(pts[1], 7.5) || !nearlyEqual(pts[2], 7.5) {
|
||||
t.Fatalf("联队第 1 名应各得 7.5，得到 A=%v B=%v", pts[1], pts[2])
|
||||
}
|
||||
if !nearlyEqual(pts[3], 10) {
|
||||
t.Fatalf("单独报名的第 2 名应独得 10 分，得到 %v", pts[3])
|
||||
}
|
||||
}
|
||||
|
||||
// 没有配份额（老数据、普通报名）时引擎的产出必须与升级前逐位一致：
|
||||
// 一条流水、整份分、整枚牌，且拆分的浮点计算不能引入零头。
|
||||
func TestWholeShareStaysExact(t *testing.T) {
|
||||
entries, _ := fixture([]participant{{entryID: 1, teamID: 7}})
|
||||
es := scoreTeamManualWithEntries(t, entries, TeamManualRank{TeamID: 7, Rank: 1})
|
||||
if len(es.Ledger) != 1 {
|
||||
t.Fatalf("独占 100%% 只该产出一条流水，得到 %d 条：%+v", len(es.Ledger), es.Ledger)
|
||||
}
|
||||
if got := es.Ledger[0].Points; got != 15 {
|
||||
t.Fatalf("独占时的积分应逐位等于 15，得到 %v", got)
|
||||
}
|
||||
if got := es.Ranked[0].Shares; len(got) != 1 || got[0].TeamID != 7 || got[0].Weight != 1 || got[0].Medal != nil {
|
||||
t.Fatalf("独占时的份额应与升级前完全一致（TeamID=7 Weight=1 Medal=nil），得到 %+v", got)
|
||||
}
|
||||
rows := teamMedalRows(t, es.Ledger, es.Ranked, 7, 8)
|
||||
if gold, _, _ := medalOf(rows, 7); gold != 1 {
|
||||
t.Fatalf("独占时该单位应记 1 枚金牌，得到 %d 枚", gold)
|
||||
}
|
||||
}
|
||||
|
||||
// splitSharePoints 的边界：权重非法（0 / 负数）按 1 处理，拆分之和恒等于总分。
|
||||
func TestSplitSharePointsKeepsTotal(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
total float64
|
||||
shares []TeamShare
|
||||
want []float64
|
||||
}{
|
||||
{"独占", 15, []TeamShare{{TeamID: 1, Weight: 1}}, []float64{15}},
|
||||
{"均分（奇数分）", 15, []TeamShare{{TeamID: 1}, {TeamID: 2}}, []float64{7.5, 7.5}},
|
||||
{"2:1（除不尽）", 15, weightedShares(int64(1), 2.0, int64(2), 1.0), []float64{10, 5}},
|
||||
{"三单位均分", 15, []TeamShare{{TeamID: 1}, {TeamID: 2}, {TeamID: 3}}, []float64{5, 5, 5}},
|
||||
{"三点均分", 10, []TeamShare{{TeamID: 1}, {TeamID: 2}, {TeamID: 3}}, []float64{10.0 / 3, 10.0 / 3, 10.0 - 2*(10.0/3)}},
|
||||
{"零权重按 1 处理", 15, weightedShares(int64(1), 0.0, int64(2), 1.0), []float64{7.5, 7.5}},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := splitSharePoints(tc.total, tc.shares)
|
||||
if len(got) != len(tc.want) {
|
||||
t.Fatalf("份数 = %d，期望 %d（%v）", len(got), len(tc.want), got)
|
||||
}
|
||||
sum := 0.0
|
||||
for i := range tc.want {
|
||||
if !nearlyEqual(got[i], tc.want[i]) {
|
||||
t.Errorf("第 %d 份 = %v，期望 %v（完整 %v）", i+1, got[i], tc.want[i], got)
|
||||
}
|
||||
sum += got[i]
|
||||
}
|
||||
if !nearlyEqual(sum, tc.total) {
|
||||
t.Errorf("拆分之和 = %v，期望 %v（零头会让榜单印出 9.999999999999998）", sum, tc.total)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,240 @@
|
||||
package domain
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// 本文件是「无联队的老数据在积分、奖牌、榜单上逐字节不变」的硬门槛回归（devdocs/19 §五）。
|
||||
//
|
||||
// 覆盖四种形态：
|
||||
// - 普通个人：个人成绩通道；
|
||||
// - 纯团体：按单位录名次的团体手工通道（球类项目走的就是它）；
|
||||
// - 双计：individual_team 的个人通道（不计入单位总分）+ 团体聚合通道；
|
||||
// - 团体报名项双通道：团体报名项（athlete_id=0）+ 个人成绩通道 + 团体手工通道，
|
||||
// 并单独覆盖「团体报名项没有名次、名次来自按单位录入的覆盖值」这一支
|
||||
// （联队改动正好动了这里：有联队报名才按份额拆，没有就还是单位独占）。
|
||||
//
|
||||
// 签名取自**联队实现之前**的代码（在 git archive HEAD 的修前副本上跑出来的），实现之后必须一字不差。
|
||||
// 签名文本只写「积分 / 名次 / 归属单位 / 榜单」这些事实，不写结构体形状：
|
||||
// 份额按 `单位ID:权重` 打印，于是给 TeamShare 加字段（奖牌整枚开关）不会把这份签名带跑偏。
|
||||
const legacyFormsGoldenSHA256 = "a2aa1c977f68b0943eade20ac4c54de51cde157c495c9104c80b0bbfca5d65ff"
|
||||
|
||||
// TestLegacyFormsScoringUnchanged 是本次改动的硬门槛：老数据（没有联队）四形态逐字节不变。
|
||||
func TestLegacyFormsScoringUnchanged(t *testing.T) {
|
||||
dump := legacyFormsDump(t)
|
||||
|
||||
// 防空转：四种形态都必须真的留下痕迹，否则签名只是一份空文本。
|
||||
for _, marker := range []string{"individual ", "team-manual ", "individual-team ", "team-entry ",
|
||||
"team-entry-override ", "team-entry-override-only ", "aggregate-valid ", "aggregate-all "} {
|
||||
if !strings.Contains(dump, marker) {
|
||||
t.Fatalf("签名里缺少形态 %q，对拍没有覆盖到它：\n%s", marker, dump)
|
||||
}
|
||||
}
|
||||
|
||||
sum := sha256.Sum256([]byte(dump))
|
||||
got := hex.EncodeToString(sum[:])
|
||||
if got != legacyFormsGoldenSHA256 {
|
||||
t.Fatalf("无联队的老数据在积分 / 奖牌 / 榜单上变了：\n签名 = %s\n期望 = %s\n\n%s",
|
||||
got, legacyFormsGoldenSHA256, dump)
|
||||
}
|
||||
}
|
||||
|
||||
// legacyFormsDump 把四种形态的引擎产出与榜单拼成一份稳定文本。
|
||||
//
|
||||
// 稳定性来源：流水与名次按切片顺序打印（引擎的输出顺序本身就是确定的），
|
||||
// 排行榜的行顺序是领域函数排序的结果（末位都有 ID 兜底，是全序），不依赖 map 遍历顺序。
|
||||
func legacyFormsDump(t *testing.T) string {
|
||||
t.Helper()
|
||||
var lines []string
|
||||
|
||||
// 个人榜的运动员信息由引擎产出反推（与读侧从库里查同一批人等价），
|
||||
// 这样签名里不会混进测试自己编的单位归属。
|
||||
athletesOf := func(es EventScore) []Athlete {
|
||||
seen := make(map[int64]bool)
|
||||
var out []Athlete
|
||||
for _, r := range es.Ranked {
|
||||
if r.AthleteID == 0 || seen[r.AthleteID] {
|
||||
continue
|
||||
}
|
||||
seen[r.AthleteID] = true
|
||||
out = append(out, Athlete{ID: r.AthleteID, Name: r.AthleteName, TeamID: r.TeamID})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
appendScore := func(name string, es EventScore, teams []Team, athletes []Athlete) {
|
||||
athletes = athletesOf(es)
|
||||
for _, l := range es.Ledger {
|
||||
lines = append(lines, fmt.Sprintf(
|
||||
"%s ledger team=%d athlete=%d entry=%d result=%d source=%s/%d points=%v countToTeam=%v voided=%v",
|
||||
name, l.TeamID, l.AthleteID, l.EntryID, l.ResultID, l.SourceType, l.SourceID,
|
||||
l.Points, l.CountToTeam, l.Voided))
|
||||
}
|
||||
for _, r := range es.Ranked {
|
||||
lines = append(lines, fmt.Sprintf(
|
||||
"%s ranked key=%s scope=%s basis=%s team=%d athlete=%d rank=%d points=%v shares=%s medals=%v/%v/%v",
|
||||
name, r.SubjectKey, r.Scope, r.Basis, r.TeamID, r.AthleteID, r.Rank, r.Points,
|
||||
formatShares(r.Shares), r.AwardMedals, r.CountToMedals, r.CountToTeamMedals))
|
||||
}
|
||||
for _, weight := range []float64{1, 0.5} {
|
||||
for _, exclude := range []bool{false, true} {
|
||||
in := StandingsInput{
|
||||
Teams: teams, Athletes: athletes, Ledger: es.Ledger, Ranked: es.Ranked,
|
||||
IndividualToTeamWeight: weight, ExcludeTeamEventMedals: exclude,
|
||||
}
|
||||
for _, row := range BuildTeamStandings(in) {
|
||||
lines = append(lines, fmt.Sprintf(
|
||||
"%s standings w=%v ex=%v rank=%d team=%d pts=%v only=%v indiv=%v %d/%d/%d medals=%d",
|
||||
name, weight, exclude, row.Rank, row.TeamID, row.Points, row.TeamOnlyPoints,
|
||||
row.IndividualPoints, row.Gold, row.Silver, row.Bronze, row.Medals))
|
||||
}
|
||||
for _, row := range BuildMedalStandings(in) {
|
||||
lines = append(lines, fmt.Sprintf(
|
||||
"%s medalboard w=%v ex=%v rank=%d team=%d pts=%v %d/%d/%d total=%d",
|
||||
name, weight, exclude, row.Rank, row.TeamID, row.Points,
|
||||
row.Gold, row.Silver, row.Bronze, row.Total))
|
||||
}
|
||||
for _, row := range BuildAthleteStandings(in) {
|
||||
lines = append(lines, fmt.Sprintf(
|
||||
"%s athleteboard w=%v ex=%v rank=%d athlete=%d team=%d pts=%v %d/%d/%d medals=%d",
|
||||
name, weight, exclude, row.Rank, row.AthleteID, row.TeamID, row.Points,
|
||||
row.Gold, row.Silver, row.Bronze, row.Medals))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 形态 1 · 普通个人：一个单位一个人，个人成绩通道（含并列）。
|
||||
{
|
||||
teams := testTeams(1001, 1002, 1003, 1004, 1005, 1006)
|
||||
entries, results := fixture([]participant{
|
||||
{entryID: 1, athleteID: 101, teamID: 1001, name: "选手A", value: 11.2},
|
||||
{entryID: 2, athleteID: 102, teamID: 1002, name: "选手B", value: 11.5},
|
||||
{entryID: 3, athleteID: 103, teamID: 1003, name: "选手C", value: 11.5},
|
||||
{entryID: 4, athleteID: 104, teamID: 1004, name: "选手D", value: 12.0},
|
||||
{entryID: 5, athleteID: 105, teamID: 1005, name: "选手E", value: 12.4},
|
||||
{entryID: 6, athleteID: 106, teamID: 1006, name: "选手F", value: 13.1},
|
||||
})
|
||||
es := mustScore(t, EventScoreInput{
|
||||
Event: individualEvent(1), Category: testCategory(),
|
||||
Channels: []ScoreChannel{athleteResultChannel(9)},
|
||||
Profiles: map[int64]ScoringProfile{9: individualTop6()},
|
||||
Entries: entries, Results: results,
|
||||
})
|
||||
appendScore("individual", es, teams, nil)
|
||||
}
|
||||
|
||||
// 形态 2 · 纯团体：按单位录的团体手工名次（含并列与顺延录入）。
|
||||
{
|
||||
teams := testTeams(1001, 1002, 1003, 1004, 1005)
|
||||
es := mustScore(t, EventScoreInput{
|
||||
Event: teamEvent(1), Category: testCategory(),
|
||||
Channels: []ScoreChannel{teamManualChannel(11)},
|
||||
Profiles: map[int64]ScoringProfile{11: teamTop6()},
|
||||
TeamRanks: []TeamManualRank{
|
||||
{TeamID: 1001, Rank: 1}, {TeamID: 1002, Rank: 2}, {TeamID: 1003, Rank: 2},
|
||||
{TeamID: 1004, Rank: 4}, {TeamID: 1005, Rank: 5},
|
||||
},
|
||||
})
|
||||
appendScore("team-manual", es, teams, nil)
|
||||
}
|
||||
|
||||
// 形态 3 · 双计（individual_team）：个人通道只记个人，单位总分按成员成绩平均排名。
|
||||
{
|
||||
teams := testTeams(1001, 1002, 1003)
|
||||
personal := athleteResultChannel(9)
|
||||
no := false
|
||||
personal.CountToTeam = &no
|
||||
entries, results := fixture([]participant{
|
||||
{entryID: 1, athleteID: 101, teamID: 1001, name: "一司1", value: 12},
|
||||
{entryID: 2, athleteID: 102, teamID: 1001, name: "一司2", value: 14},
|
||||
{entryID: 3, athleteID: 103, teamID: 1002, name: "二司1", value: 13},
|
||||
{entryID: 4, athleteID: 104, teamID: 1002, name: "二司2", value: 15},
|
||||
{entryID: 5, athleteID: 105, teamID: 1003, name: "三司1", value: 16},
|
||||
{entryID: 6, athleteID: 106, teamID: 1003, name: "三司2", value: 16},
|
||||
})
|
||||
es := mustScore(t, EventScoreInput{
|
||||
Event: teamEvent(1), Category: testCategory(),
|
||||
Channels: []ScoreChannel{personal, teamAggregateChannel(11)},
|
||||
Profiles: map[int64]ScoringProfile{9: individualTop6(), 11: teamTop6()},
|
||||
Entries: entries, Results: results,
|
||||
})
|
||||
appendScore("individual-team", es, teams, nil)
|
||||
}
|
||||
|
||||
// 形态 4 · 团体报名项双通道（团体报名项 athlete_id=0 + 个人成绩通道 + 团体手工通道）。
|
||||
{
|
||||
teams := testTeams(1001, 1002, 1003)
|
||||
entries, results := fixture([]participant{
|
||||
{entryID: 1, teamID: 1001, value: 90, rank: 1},
|
||||
{entryID: 2, teamID: 1002, value: 80, rank: 2},
|
||||
{entryID: 3, teamID: 1003, value: 70, rank: 3},
|
||||
})
|
||||
in := EventScoreInput{
|
||||
Event: teamEvent(1), Category: testCategory(),
|
||||
Channels: []ScoreChannel{athleteResultChannel(9), teamManualChannel(11)},
|
||||
Profiles: map[int64]ScoringProfile{9: individualTop6(), 11: teamTop6()},
|
||||
Entries: entries, Results: results,
|
||||
}
|
||||
// 4a：名次只来自团体报名项自己的 results.rank。
|
||||
appendScore("team-entry", mustScore(t, in), teams, nil)
|
||||
|
||||
// 4b：名次来自「按单位录入的团体名次」（覆盖值优先于报名项自己的名次）。
|
||||
withOverride := in
|
||||
withOverride.TeamRanks = []TeamManualRank{{TeamID: 1001, Rank: 2}, {TeamID: 1002, Rank: 1}}
|
||||
appendScore("team-entry-override", mustScore(t, withOverride), teams, nil)
|
||||
|
||||
// 4c：团体报名项没有名次，名次只有按单位录入的覆盖值（合成名次那一支）。
|
||||
blank, blankResults := fixture([]participant{
|
||||
{entryID: 1, teamID: 1001, value: 90},
|
||||
{entryID: 2, teamID: 1002, value: 80},
|
||||
{entryID: 3, teamID: 1003, value: 70},
|
||||
})
|
||||
onlyOverride := in
|
||||
onlyOverride.Entries = blank
|
||||
onlyOverride.Results = blankResults
|
||||
onlyOverride.TeamRanks = []TeamManualRank{{TeamID: 1001, Rank: 3}, {TeamID: 1002, Rank: 1}, {TeamID: 1003, Rank: 2}}
|
||||
appendScore("team-entry-override-only", mustScore(t, onlyOverride), teams, nil)
|
||||
}
|
||||
|
||||
// 形态 5 · 无并列的团体聚合（avg / all 两种分母口径），补上聚合通道的另一半覆盖面。
|
||||
{
|
||||
teams := testTeams(1001, 1002)
|
||||
for _, mode := range []AvgMode{AvgModeValid, AvgModeAll} {
|
||||
ev := teamEvent(1)
|
||||
ev.AvgMode = mode
|
||||
entries, results := fixture([]participant{
|
||||
{entryID: 1, athleteID: 101, teamID: 1001, name: "一司1", value: 10},
|
||||
{entryID: 2, athleteID: 102, teamID: 1001, name: "一司2", value: 14},
|
||||
{entryID: 3, athleteID: 103, teamID: 1002, name: "二司1", value: 12, noValue: true},
|
||||
{entryID: 4, athleteID: 104, teamID: 1002, name: "二司2", value: 16},
|
||||
})
|
||||
es := mustScore(t, EventScoreInput{
|
||||
Event: ev, Category: testCategory(),
|
||||
Channels: []ScoreChannel{teamAggregateChannel(11)},
|
||||
Profiles: map[int64]ScoringProfile{11: teamTop6()},
|
||||
Entries: entries, Results: results,
|
||||
})
|
||||
appendScore("aggregate-"+string(mode), es, teams, nil)
|
||||
}
|
||||
}
|
||||
|
||||
return strings.Join(lines, "\n") + "\n"
|
||||
}
|
||||
|
||||
// formatShares 把归属份额打印成 `单位ID:权重` 列表。
|
||||
// 刻意只取这两个字段：签名要盯的是「分给了谁」，不是结构体里后来又加了什么开关。
|
||||
func formatShares(shares []TeamShare) string {
|
||||
if len(shares) == 0 {
|
||||
return "-"
|
||||
}
|
||||
parts := make([]string, 0, len(shares))
|
||||
for _, s := range shares {
|
||||
parts = append(parts, fmt.Sprintf("%d:%v", s.TeamID, s.Weight))
|
||||
}
|
||||
return "[" + strings.Join(parts, ",") + "]"
|
||||
}
|
||||
@@ -39,8 +39,11 @@ type EventScore struct {
|
||||
|
||||
// RankedResult 记录「某条报名项在某通道下拿到的名次与原始积分」。
|
||||
// Points 尚未乘个人→单位系数，因此可直接用于奖牌判定与分项成绩表。
|
||||
// Shares 是该名次的归属单位；当前只有「整体归主单位」一种口径（联队未实现），
|
||||
// 保留份额结构是因为导出 / 实时快照等消费方按份额遍历。
|
||||
//
|
||||
// Shares 是该名次的归属单位份额：报名项配了联队就是多条（如 A、B 各半），否则是主单位独占
|
||||
// 一条；积分按 Weight 拆、奖牌按 CountsMedal 整枚各记（见 TeamShare）。名次本身只有一条，
|
||||
// 分数与奖牌的下发（拆成几份、记给谁）全部由 Shares 决定——流水侧在 ledgerFromRanked 拆成多行，
|
||||
// 奖牌侧在 standings.teamMedals 逐份额记牌。
|
||||
type RankedResult struct {
|
||||
EntryID int64
|
||||
ResultID int64
|
||||
@@ -295,6 +298,13 @@ func collectTeamManualCandidates(in EventScoreInput, ch ScoreChannel) []candidat
|
||||
if taken[or.teamID] {
|
||||
continue
|
||||
}
|
||||
// 联队：该主单位在本组别报了联队（团体行 + 多单位份额）时，这条按单位录的名次就是
|
||||
// 联队的名次，份额取自那条报名——否则 A+B 拿到的名次会整份记在 A 头上，B 一分没有。
|
||||
// 没有联队报名（老数据、普通报名）时仍走下面的合成报名项，名次主体照样是单位。
|
||||
if joint, ok := jointTeamEntry(in, or.teamID); ok {
|
||||
out = append(out, candidate{entry: joint, rankIn: or.rank})
|
||||
continue
|
||||
}
|
||||
// 合成报名项：ID=0 表示「不对应任何一条报名项」，团体名次的主体是单位。
|
||||
out = append(out, candidate{
|
||||
entry: Entry{TeamID: or.teamID},
|
||||
@@ -304,6 +314,48 @@ func collectTeamManualCandidates(in EventScoreInput, ch ScoreChannel) []candidat
|
||||
return out
|
||||
}
|
||||
|
||||
// jointTeamEntry 找「主单位 teamID 在本组别的联队报名」：团体行（athlete_id=0）+ 配了多个单位的份额。
|
||||
//
|
||||
// 团体名次是按单位录的（channel_manual_ranks 的主体只有单位），联队份额只能挂在报名上，
|
||||
// 所以录名次时得回头找这条报名。找不到（含只配了一个单位的普通报名）就返回 false，
|
||||
// 调用方退回「主单位独占 100%」的合成报名项。
|
||||
//
|
||||
// 为什么把「只有一个单位」也排除：那样与独占 100% 等价，却会把名次的身份从单位（subject_key
|
||||
// `t:<id>`）换成报名项（`e:<id>`），channel_ranks 的既有行会跟着变——老数据必须逐字节不变。
|
||||
//
|
||||
// 同一个组别同一主单位最多只有一条团体行（entries 的唯一索引兜着），真出现多条且份额不一致时
|
||||
// 退回独占：宁可少拆，也不能随便挑一条把分拆错。
|
||||
func jointTeamEntry(in EventScoreInput, teamID int64) (Entry, bool) {
|
||||
var found Entry
|
||||
ok := false
|
||||
for _, e := range in.Entries {
|
||||
if e.AthleteID != 0 || e.TeamID != teamID || !entryMatches(in, e) || !e.Status.rankable() {
|
||||
continue
|
||||
}
|
||||
if len(e.TeamShares) < 2 {
|
||||
continue
|
||||
}
|
||||
if ok && !sameShares(found.TeamShares, e.TeamShares) {
|
||||
return Entry{}, false
|
||||
}
|
||||
found, ok = e, true
|
||||
}
|
||||
return found, ok
|
||||
}
|
||||
|
||||
// sameShares 判断两组份额是否一致（单位集合与各自权重、奖牌开关都比）。
|
||||
func sameShares(a, b []TeamShare) bool {
|
||||
if len(a) != len(b) {
|
||||
return false
|
||||
}
|
||||
for i := range a {
|
||||
if a[i].TeamID != b[i].TeamID || !nearlyEqual(a[i].Weight, b[i].Weight) || a[i].CountsMedal() != b[i].CountsMedal() {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func scoreByResult(in EventScoreInput, ch ScoreChannel, profile ScoringProfile) ([]RankedResult, error) {
|
||||
cands, err := collectCandidates(in, ch)
|
||||
if err != nil {
|
||||
@@ -449,7 +501,7 @@ func rankedResult(in EventScoreInput, ch ScoreChannel, c candidate, rank int, po
|
||||
AthleteID: c.entry.AthleteID,
|
||||
AthleteName: c.entry.AthleteName,
|
||||
TeamID: c.entry.primaryTeamID(),
|
||||
Shares: wholeShare(c.entry.primaryTeamID()),
|
||||
Shares: ResolveShares(c.entry.TeamShares, c.entry.primaryTeamID()),
|
||||
Rank: rank,
|
||||
Points: points,
|
||||
Status: c.result.Status,
|
||||
@@ -573,6 +625,10 @@ func scoreByAggregate(in EventScoreInput, ch ScoreChannel, profile ScoringProfil
|
||||
Rank: g.startRank,
|
||||
Points: pts,
|
||||
}
|
||||
// 聚合名次不对应任何一条报名项（EntryID=0，主体是单位或运动员），读取侧
|
||||
// （channel_ranks → buildRanked）没有报名项可以回查份额，只能按主体单位独占；
|
||||
// 引擎必须同口径，否则「流水按份额拆了、奖牌榜还按单位独占」，两处对不上。
|
||||
// 因此联队 + 聚合通道不拆份额（已记进 devdocs/19 的未决项：聚合按主单位分桶）。
|
||||
if ch.Scope == ScopeTeam {
|
||||
rr.TeamID = c.subject
|
||||
rr.Shares = wholeShare(c.subject)
|
||||
@@ -649,9 +705,9 @@ func ledgerFromRanked(in EventScoreInput, ch ScoreChannel, ranked []RankedResult
|
||||
if sourceID == 0 {
|
||||
sourceID = ch.ID
|
||||
}
|
||||
for _, s := range rr.Shares {
|
||||
pts := rr.Points * s.Weight
|
||||
if pts == 0 {
|
||||
split := splitSharePoints(rr.Points, rr.Shares)
|
||||
for i, s := range rr.Shares {
|
||||
if split[i] == 0 {
|
||||
continue
|
||||
}
|
||||
out = append(out, LedgerEntry{
|
||||
@@ -664,7 +720,7 @@ func ledgerFromRanked(in EventScoreInput, ch ScoreChannel, ranked []RankedResult
|
||||
ChannelID: ch.ID,
|
||||
SourceType: SourceResult,
|
||||
SourceID: sourceID,
|
||||
Points: pts,
|
||||
Points: split[i],
|
||||
CountToTeam: ch.countToTeam(),
|
||||
})
|
||||
}
|
||||
@@ -688,10 +744,60 @@ func subjectKeyOf(rr RankedResult) string {
|
||||
}
|
||||
}
|
||||
|
||||
// wholeShare 构造「主单位独占 100%」的归属份额。联队拆分未实现，这里只产出这一种口径。
|
||||
// ResolveShares 把「报名项配的份额」解析成最终归属份额：配了（联队）就用配置，
|
||||
// 没配就是主单位独占 100%，与升级前逐字段一致。读侧（channel_ranks → RankedResult）
|
||||
// 与引擎共用它，避免两边各写一份「没有份额时怎么办」。
|
||||
func ResolveShares(configured []TeamShare, teamID int64) []TeamShare {
|
||||
if len(configured) > 0 {
|
||||
return configured
|
||||
}
|
||||
return wholeShare(teamID)
|
||||
}
|
||||
|
||||
// wholeShare 构造「主单位独占 100%」的归属份额：没有联队配置时的唯一口径。
|
||||
func wholeShare(teamID int64) []TeamShare {
|
||||
if teamID == 0 {
|
||||
return nil
|
||||
}
|
||||
return []TeamShare{{TeamID: teamID, Weight: 1}}
|
||||
}
|
||||
|
||||
// splitSharePoints 把一条成绩的积分按份额拆给各成员单位，返回值与 shares 一一对应。
|
||||
//
|
||||
// 权重是相对值（默认各 1 = 均分），先按权重之和归一：联队的两个单位各 1 份时总分照旧，
|
||||
// 2:1 时也拆成两单位之和等于原来那一份分——**份额只改「分记在谁头上」，不改变总分**。
|
||||
// 没有配份额（老数据、普通报名）时是单条独占：total·1/1，结果与升级前逐位相同。
|
||||
//
|
||||
// 最后一份取「总分减去前面各份」的余数，而不是再算一次乘法：2:1 这种除不尽的权重
|
||||
// 各份直接算会剩下 1e-15 级零头，榜单上就会印出 9.999999999999998 这种数。
|
||||
//
|
||||
// 权重 <= 0 按 1 处理：库里有 CHECK(points_share > 0) 兜着，这里是引擎侧的兜底，
|
||||
// 与其它地方的「零值按 1」口径（multiplier / effectiveWeight）一致。
|
||||
func splitSharePoints(total float64, shares []TeamShare) []float64 {
|
||||
out := make([]float64, len(shares))
|
||||
if len(shares) == 0 {
|
||||
return out
|
||||
}
|
||||
sum := 0.0
|
||||
for _, s := range shares {
|
||||
sum += shareWeight(s)
|
||||
}
|
||||
acc := 0.0
|
||||
for i, s := range shares {
|
||||
if i == len(shares)-1 {
|
||||
out[i] = total - acc
|
||||
break
|
||||
}
|
||||
out[i] = total * shareWeight(s) / sum
|
||||
acc += out[i]
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// shareWeight 取份额的积分权重，零值与负值按 1 处理（见 splitSharePoints）。
|
||||
func shareWeight(s TeamShare) float64 {
|
||||
if s.Weight <= 0 {
|
||||
return 1
|
||||
}
|
||||
return s.Weight
|
||||
}
|
||||
@@ -328,8 +328,9 @@ func pickMedalChannels(ranked []RankedResult, excludeTeam bool) []RankedResult {
|
||||
return out
|
||||
}
|
||||
|
||||
// teamMedals 统计单位奖牌榜。按 Shares 逐份额记牌：当前只有「主单位独占 100%」一种口径，
|
||||
// 将来若支持联队拆分，每个成员单位都会各记一枚。
|
||||
// teamMedals 统计单位奖牌榜。按 Shares 逐份额记牌：每个份额各记**一枚整牌**，
|
||||
// 联队拿到的金牌因此两个成员单位各记 1 枚（不是各 0.5 枚，口径见 TeamShare.Medal）。
|
||||
// 份额里的 Medal 显式关掉时该单位不记这枚牌（积分份额 Weight 不参与奖牌计算）。
|
||||
//
|
||||
// 两层开关（devdocs 17 §4.5）：
|
||||
// - 粗粒度总闸 StandingsInput.ExcludeTeamEventMedals：为 true 时团体项目的奖牌一律不进单位榜；
|
||||
@@ -347,6 +348,9 @@ func teamMedals(in StandingsInput) map[int64]medalTally {
|
||||
continue
|
||||
}
|
||||
for _, s := range rr.Shares {
|
||||
if !s.CountsMedal() {
|
||||
continue
|
||||
}
|
||||
t := out[s.TeamID]
|
||||
switch medal {
|
||||
case 1:
|
||||
|
||||
@@ -288,14 +288,31 @@ type ScoringProfile struct {
|
||||
Rules []ScoringRule `json:"rules"`
|
||||
}
|
||||
|
||||
// TeamShare 是一条成绩的归属单位份额。联队拆分未实现，引擎只产出「主单位独占 100%」；
|
||||
// 保留结构是因为导出 / 实时快照等消费方按份额遍历 RankedResult.Shares。
|
||||
// TeamShare 是一条成绩的归属单位份额：两个单位合并成联队参赛时，一条成绩由多个单位共享。
|
||||
//
|
||||
// 积分与奖牌是两套口径，必须分开表达（devdocs/19 第三节的拍板结果）：
|
||||
// - Weight 只决定**积分**怎么拆，是相对权重（按权重之和归一，1+1 就是各一半；缺省值 1）；
|
||||
// 奇数分允许出现 0.5 这样的小数，榜单上就写 7.5；
|
||||
// - Medal 只决定这枚**奖牌**是否整枚记给本单位。联队拿到的金牌两个单位各记 1 枚，
|
||||
// 不按 Weight 拆成半枚——奖牌榜数的是整数枚，跟着权重拆会立刻错。
|
||||
//
|
||||
// 普通报名（没有联队）与联队用同一个结构表达：一条 {主单位, Weight:1}，也就是「主单位独占 100%」，
|
||||
// 与升级前 wholeShare 的产出逐字段一致。
|
||||
type TeamShare struct {
|
||||
TeamID int64 `json:"teamId"`
|
||||
Weight float64 `json:"weight"`
|
||||
// Medal 为 nil 表示按缺省处理（整枚记给本单位），与通道开关 CountToTeam 的 *bool 写法同源：
|
||||
// 零值必须落在「老数据的行为」那一侧，否则既有调用方构造的 {TeamID, Weight} 会突然丢掉奖牌。
|
||||
Medal *bool `json:"medal,omitempty"`
|
||||
}
|
||||
|
||||
// Entry 报名项：某单位派某人/某队参加某小项。
|
||||
// CountsMedal 判断这枚奖牌是否整枚记给本单位；未配置时按整枚处理。
|
||||
func (s TeamShare) CountsMedal() bool {
|
||||
return s.Medal == nil || *s.Medal
|
||||
}
|
||||
|
||||
// Entry 报名项：某单位派某人/某队参加某小项。TeamID 是**主单位**（联队时也保留它，
|
||||
// 报名项的唯一键、榜单兜底、导入去重都还认这一个），联队的其余成员单位在 TeamShares 里。
|
||||
type Entry struct {
|
||||
ID int64 `json:"id"`
|
||||
EventID int64 `json:"eventId"`
|
||||
@@ -308,6 +325,9 @@ type Entry struct {
|
||||
Seed string `json:"seed,omitempty"`
|
||||
Status EntryStatus `json:"status"`
|
||||
Remark string `json:"remark,omitempty"`
|
||||
// TeamShares 是这条报名的归属份额配置：空 = 主单位独占 100%（老数据、普通报名），
|
||||
// 多条 = 联队。引擎只读不改，取分的唯一入口是 ResolveShares。
|
||||
TeamShares []TeamShare `json:"teamShares,omitempty"`
|
||||
}
|
||||
|
||||
// Result 成绩；一条报名项一条成绩。
|
||||
|
||||
Reference in new issue
Block a user