feat(entry): 团体报名「队员身份」—— 一条报名挂多个运动员，标识用号码布；版本 dev_0.5.6
## 需求（主人原话）
> 「双打我给他定义的是团队赛事，团队赛事不应该本来就是可以配置多个人的吗」
> 「把队员身份证留住，**应该是服务于整个团体报名**」
**现状问题**：界面（`EntryPicker`）**本来就能勾多个运动员**，但提交时只把姓名拼成文字
（`entrySelection.ts` 的 `input.athletes.map(a => a.name)` 存进 `entries.member_names TEXT`）→ **身份全丢**
→ 系统不知道队里坐着谁 → **所有团体/对抗项目都给不出个人分、个人奖牌，上不了个人积分榜**。
## 口径
- **运动员的唯一标识是号码布**（主人明确更正，不是证件号）。
- **每个队员各拿一份完整的个人分** —— 是「**复制**」不是「拆」（与联队 `splitSharePoints` 正好相反）。
- **个人奖牌每人各一枚**；**单位总分与单位奖牌不受影响**（由通道开关 `count_to_team` / `count_to_team_medals` 控制）。
## 一、数据
- 迁移 `0026_entry_athletes.sql`：新表 `entry_athletes(entry_id, athlete_id, sort_order)`，PK `(entry_id, athlete_id)`，两个外键都 `ON DELETE CASCADE`。
`entries` **一个字节没动**（`member_names` 保留为显示用名单；多队唯一键 `(category_id,team_id,squad) WHERE athlete_id IS NULL` 未触碰）。
- **老数据回填（尽力而为）**：拿 `member_names` 去 `athletes` 匹配 —— **号码布优先**，其次「姓名 + 单位」且同单位同名唯一；**匹配不上留空**，不硬猜。
## 二、引擎
- `RankedResult.MemberCopy`（报名项那份 `false`、队员副本 `true`）；**只在 `scope=athlete` 通道展开**（`scope=team` 与 `basis=aggregate` 不展开）。
- **单位维度不重复计算的三道锁**（本单最大的坑）：
1. 队员副本流水 `count_to_team` **恒为 false** —— 单位总分那条 SQL 第一句就跳过它，而个人榜不看这个开关；
2. 单位奖牌仍按**报名项**去重、且报名项那份**排在最前**；
3. 队员副本**照抄 `TeamID` 与 `Shares`**（不换单位、不另造份额 —— 联队报名尤其危险）。
反面也测了：个人奖牌若按报名项去重会**一枚都发不出来**（被 `AthleteID=0` 那份吃掉），故改为按「报名项 + 运动员」去重。
## 三、写 / 读
- `PUT /api/entries/{id}/athletes`（recorder+、CSRF）：body `{"athletes":[{"athleteId":12}],"requestId":"..."}`，**只认 athleteId**；空数组＝清空；
改完当场重算推榜。400：athleteId 缺/不存在、同一人两次、>30 人、个人报名不能挂队员。
- 读：`entryDTO.athletes: [{athleteId, name, bib}]`（**始终是数组**）；`memberNames` 原样保留，**两者可并存**（没档案的人只能留文字）。
## 四、导入
- 报名表「队员名单」列现在**按号码布认人**（命中即关联，同时保留文字）；⚠️ **姓名完全不做匹配**（同名会认错，而认错的分已经上了榜）；匹配不上**不报错、只当文字**。
- 边界逐条有 notice/报错：跨单位号码布**照关联 + notice**（号码布是唯一标识）；同格重号只关联一次 + notice；**个人行**写了号码布只留文字 + notice；**认出 >30 人整行拦下**；成功时一条汇总 notice。
- **更新路必须重算**：老表先导入、成绩已发布，之后补上号码布重传 —— 不在更新路重算就会出现「名单里有队员、榜上没有他」（删掉该条件即红）。
## 五、界面与显示
- 补报名勾的人**真正提交**（导入成功后追加 `PUT /athletes`，**只发需要变的**：勾了人的单位、以及原来有队员这次一个没勾的（发 `[]`）；一个都没勾且原来也没队员的一律不发）；**队员写失败单独提示**（报名本身已加入，不冒充「加入报名失败」）。
- **改队员**：录入页「运动员/队」那格的**「队员」小按钮**（只有纯团体行才有），弹窗勾选式名单；**与「成员单位与份额」是两个独立写请求**（份额管「分给哪些单位」、队员管「这条报名里有哪几个人」）。
- 显示统一写法 **`姓名（号码布）`**（导出件；大屏只写姓名与 ` / ` 分隔 —— 号码布太长会把整屏字号压下去）；**没有队员关联的老数据一个字不变**；
⚠️ **一条报名仍只占一行**（有护栏测试钉着）；`squad`（队）与 `athletes`（队员）**正交**。
## 验证
- 全量自检两轮**全绿、`EXIT=0`**：服务端 14 包 / 前端 **921 例** 0 fail / Console 68 例 0 fail。
- 各块先红后绿并留原始输出；**老数据零变化**有 golden 对拍（引擎层 / 接口层 / 导出层逐行 dump）。
## 文档
`docs/报名名单导入规范.md`（队员列语义升级，列数仍是 13）、`docs/使用手册.md`（新增 4.13 团体报名的队员）、
`docs/升级说明.md`（新增 `dev_0.5.6` 一节）。
## 版本
`dev_0.5.5` → **`dev_0.5.6`**（含数据迁移 `0026`）；安装器素材同步重生成（照例只动 `brand.bmp` 两张）。
This commit is contained in:
AskaEth committed
1 parent
7a3e4ad365
commit
99c91f99f7
57 files changed
+4903
-94
No files matched your search
@@ -0,0 +1,267 @@
|
||||
package domain
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// 本文件钉住「团体报名的队员身份」在引擎里的口径（devdocs/20）：
|
||||
//
|
||||
// - 一条团体报名（athlete_id 为空）可以挂多个队员；个人通道给**每个队员各一份完整的**分
|
||||
// （不是按份额拆，与联队 entry_team_shares 的「拆」相反），个人奖牌也是每人各一枚；
|
||||
// - **单位维度一份都不多**：单位总分与单位奖牌仍然只算这条报名一次，由通道开关
|
||||
// count_to_team / count_to_team_medals 控制；
|
||||
// - 没有队员关联的老数据（Entry.Athletes 为空）逐字节不变。
|
||||
|
||||
// memberEntry 造一条带队员的团体报名。
|
||||
func memberEntry(entryID, teamID int64, value float64, members ...EntryAthlete) participant {
|
||||
return participant{entryID: entryID, teamID: teamID, value: value, members: members}
|
||||
}
|
||||
|
||||
// twoDoubles 是「一个单位派两个人打双打 + 另一个单位一个人」的最小现场形态：
|
||||
// 成绩越小越好（compare=asc，与 100 米那种打法一致）。
|
||||
func twoDoubles() ([]Entry, []Result) {
|
||||
return fixture([]participant{
|
||||
memberEntry(1, 1001, 11.2,
|
||||
EntryAthlete{AthleteID: 201, Name: "队员一"},
|
||||
EntryAthlete{AthleteID: 202, Name: "队员二"}),
|
||||
{entryID: 2, teamID: 1002, value: 11.5},
|
||||
})
|
||||
}
|
||||
|
||||
// twoDoublesLegacy 是升级前的老数据形态：同样两条报名、同样的成绩，但队员只有姓名文字
|
||||
// （认不出是哪个人），也就是回填不出关联或干脆没回填的那些报名。
|
||||
func twoDoublesLegacy() ([]Entry, []Result) {
|
||||
entries, results := twoDoubles()
|
||||
entries[0].Athletes = nil
|
||||
return entries, results
|
||||
}
|
||||
|
||||
// doublesEventInput 是双打的计分输入：团体项目 + 一个按成绩排名的个人通道。
|
||||
// teamFlagsOff 打开通道的两个单位开关「都不计入」（现场的双打口径）。
|
||||
func doublesEventInput(entries []Entry, results []Result, teamFlagsOff bool) EventScoreInput {
|
||||
ch := athleteResultChannel(9)
|
||||
if teamFlagsOff {
|
||||
ch.CountToTeam = boolPtr(false)
|
||||
ch.CountToTeamMedals = boolPtr(false)
|
||||
}
|
||||
return EventScoreInput{
|
||||
Event: teamEvent(1), Category: testCategory(),
|
||||
Channels: []ScoreChannel{ch},
|
||||
Profiles: map[int64]ScoringProfile{9: individualTop6()},
|
||||
Entries: entries, Results: results,
|
||||
}
|
||||
}
|
||||
|
||||
// 双打：两个队员各拿一份完整的个人分（第 1 名 10 分 → 两人各 10 分，不是各 5 分），
|
||||
// 单位总分仍然只有一份 10 分；个人奖牌每人各一枚，单位奖牌只有一枚。
|
||||
func TestTeamEntryMembersScoreIndividually(t *testing.T) {
|
||||
entries, results := twoDoubles()
|
||||
es := mustScore(t, doublesEventInput(entries, results, false))
|
||||
|
||||
// 名次明细：报名项自己那一份（单位维度认它）+ 每个队员一份个人副本。
|
||||
wantRanked := []string{
|
||||
"key=e:1 scope=athlete basis=result team=1001 athlete=0 rank=1 points=10",
|
||||
"key=e:1:a:201 scope=athlete basis=result team=1001 athlete=201 rank=1 points=10",
|
||||
"key=e:1:a:202 scope=athlete basis=result team=1001 athlete=202 rank=1 points=10",
|
||||
"key=e:2 scope=athlete basis=result team=1002 athlete=0 rank=2 points=8",
|
||||
}
|
||||
if got := rankedSummary(es.Ranked); strings.Join(got, "\n") != strings.Join(wantRanked, "\n") {
|
||||
t.Fatalf("名次明细不对：\n得到 %s期望 %s", strings.Join(got, "\n"), strings.Join(wantRanked, "\n"))
|
||||
}
|
||||
|
||||
// 流水：单位那一份照旧（count_to_team=true），队员的个人分是「只记个人」的额外流水——
|
||||
// 它们 count_to_team=false，所以既不会让单位总分变成两份，也不会进单位奖牌。
|
||||
wantLedger := []string{
|
||||
"team=1001 athlete=0 entry=1 result=100 points=10 countToTeam=true",
|
||||
"team=1001 athlete=201 entry=1 result=100 points=10 countToTeam=false",
|
||||
"team=1001 athlete=202 entry=1 result=100 points=10 countToTeam=false",
|
||||
"team=1002 athlete=0 entry=2 result=200 points=8 countToTeam=true",
|
||||
}
|
||||
if got := ledgerSummary(es.Ledger); strings.Join(got, "\n") != strings.Join(wantLedger, "\n") {
|
||||
t.Fatalf("流水不对：\n得到 %s期望 %s", strings.Join(got, "\n"), strings.Join(wantLedger, "\n"))
|
||||
}
|
||||
|
||||
in := StandingsInput{Teams: testTeams(1001, 1002), Ledger: es.Ledger, Ranked: es.Ranked}
|
||||
|
||||
// 单位总分只算一次：10 分（不是 30 分），金牌一枚（不是三枚）。
|
||||
rows := BuildTeamStandings(in)
|
||||
if len(rows) != 2 {
|
||||
t.Fatalf("积分榜应有两行，得到 %+v", rows)
|
||||
}
|
||||
if rows[0].TeamID != 1001 || !nearlyEqual(rows[0].Points, 10) ||
|
||||
rows[0].TeamOnlyPoints != 10 || rows[0].IndividualPoints != 0 || rows[0].Gold != 1 || rows[0].Medals != 1 {
|
||||
t.Fatalf("双打单位那一行 = %+v，期望总分 10（仅单位 10、个人 0）、1 枚金牌（不进个人分）", rows[0])
|
||||
}
|
||||
if rows[1].TeamID != 1002 || rows[1].Points != 8 || rows[1].Silver != 1 {
|
||||
t.Fatalf("对照单位那一行 = %+v，期望 8 分 1 银", rows[1])
|
||||
}
|
||||
medals := BuildMedalStandings(in)
|
||||
if medals[0].TeamID != 1001 || medals[0].Gold != 1 || medals[0].Total != 1 {
|
||||
t.Fatalf("单位奖牌榜第一行 = %+v，期望单位 1001 只记 1 枚金牌", medals[0])
|
||||
}
|
||||
|
||||
// 个人榜：两个队员各一份满分、各一枚金牌。
|
||||
athletes := BuildAthleteStandings(in)
|
||||
wantAthletes := []string{
|
||||
"athlete=201 team=1001 points=10 1/0/0 medals=1",
|
||||
"athlete=202 team=1001 points=10 1/0/0 medals=1",
|
||||
}
|
||||
got := make([]string, 0, len(athletes))
|
||||
for _, row := range athletes {
|
||||
got = append(got, fmt.Sprintf("athlete=%d team=%d points=%v %d/%d/%d medals=%d",
|
||||
row.AthleteID, row.TeamID, row.Points, row.Gold, row.Silver, row.Bronze, row.Medals))
|
||||
}
|
||||
// 两人同分同牌，排序落到姓名（队员一 < 队员二），顺序稳定。
|
||||
if strings.Join(got, "\n") != strings.Join(wantAthletes, "\n") {
|
||||
t.Fatalf("个人榜不对：\n得到 %s期望 %s", strings.Join(got, "\n"), strings.Join(wantAthletes, "\n"))
|
||||
}
|
||||
}
|
||||
|
||||
// 现场的双打口径（通道两个单位开关都关掉）：队员照拿个人分与个人奖牌，单位一分一牌都不拿。
|
||||
func TestTeamEntryMembersWithTeamFlagsOff(t *testing.T) {
|
||||
entries, results := twoDoubles()
|
||||
es := mustScore(t, doublesEventInput(entries, results, true))
|
||||
|
||||
in := StandingsInput{Teams: testTeams(1001, 1002), Ledger: es.Ledger, Ranked: es.Ranked}
|
||||
for _, row := range BuildTeamStandings(in) {
|
||||
if row.Points != 0 || row.Medals != 0 {
|
||||
t.Errorf("单位 %d 在「都不计入」下应为 0 分 0 牌，得到 %+v", row.TeamID, row)
|
||||
}
|
||||
}
|
||||
for _, row := range BuildMedalStandings(in) {
|
||||
if row.Total != 0 {
|
||||
t.Errorf("单位 %d 在「都不计入」下不该有奖牌，得到 %+v", row.TeamID, row)
|
||||
}
|
||||
}
|
||||
athletes := BuildAthleteStandings(in)
|
||||
if len(athletes) != 2 || athletes[0].Points != 10 || athletes[0].Gold != 1 ||
|
||||
athletes[1].Points != 10 || athletes[1].Gold != 1 {
|
||||
t.Fatalf("队员的个人分与个人奖牌照发，得到 %+v", athletes)
|
||||
}
|
||||
}
|
||||
|
||||
// 联队 + 队员同时存在（A+B 联队派两个人打双打）：两套机制各管一维，不许互相污染——
|
||||
// 单位那一份仍按份额**拆**（各 5 分）、奖牌各 1 枚；队员各拿**一整份**（各 10 分，不是各 5 分）。
|
||||
func TestJointTeamWithMembersKeepsSharesAndCopiesSeparate(t *testing.T) {
|
||||
entries, results := fixture([]participant{
|
||||
{entryID: 1, teamID: 1001, value: 11.2,
|
||||
shares: []TeamShare{{TeamID: 1001, Weight: 1}, {TeamID: 1002, Weight: 1}},
|
||||
members: []EntryAthlete{{AthleteID: 201, Name: "队员一"}, {AthleteID: 202, Name: "队员二"}}},
|
||||
})
|
||||
es := mustScore(t, doublesEventInput(entries, results, false))
|
||||
|
||||
// 流水：单位那两份各 5 分（按份额拆），队员那两份各 10 分（整份，只记个人）。
|
||||
ledger := ledgerSummary(es.Ledger)
|
||||
want := []string{
|
||||
"team=1001 athlete=0 entry=1 result=100 points=5 countToTeam=true",
|
||||
"team=1002 athlete=0 entry=1 result=100 points=5 countToTeam=true",
|
||||
"team=1001 athlete=201 entry=1 result=100 points=10 countToTeam=false",
|
||||
"team=1001 athlete=202 entry=1 result=100 points=10 countToTeam=false",
|
||||
}
|
||||
if strings.Join(ledger, "\n") != strings.Join(want, "\n") {
|
||||
t.Fatalf("联队 + 队员的流水不对：\n得到 %s期望 %s", strings.Join(ledger, "\n"), strings.Join(want, "\n"))
|
||||
}
|
||||
|
||||
in := StandingsInput{Teams: testTeams(1001, 1002), Ledger: es.Ledger, Ranked: es.Ranked}
|
||||
for _, row := range BuildMedalStandings(in) {
|
||||
if row.Gold != 1 || row.Total != 1 {
|
||||
t.Errorf("联队单位 %d 应各记 1 枚金牌（队员不重复发牌），得到 %+v", row.TeamID, row)
|
||||
}
|
||||
}
|
||||
athletes := BuildAthleteStandings(in)
|
||||
if len(athletes) != 2 || athletes[0].Points != 10 || athletes[1].Points != 10 {
|
||||
t.Fatalf("联队里的队员各拿一整份个人分，得到 %+v", athletes)
|
||||
}
|
||||
}
|
||||
|
||||
// 硬门槛：挂上队员之后，**单位维度逐字节不变**。
|
||||
//
|
||||
// 同一份成绩算两遍：一遍是升级前的老数据形态（只有姓名文字、认不出人），一遍是升级后
|
||||
// 回填出队员身份。单位那一份名次、流水、总分、奖牌必须一模一样——队员的分只走个人维度，
|
||||
// 绝不能渗进单位总分或单位奖牌（那是本单最容易错的地方）。
|
||||
func TestTeamEntryMembersKeepTeamDimensionByteIdentical(t *testing.T) {
|
||||
legacyEntries, legacyResults := twoDoublesLegacy()
|
||||
without := mustScore(t, doublesEventInput(legacyEntries, legacyResults, false))
|
||||
|
||||
entries, results := twoDoubles()
|
||||
with := mustScore(t, doublesEventInput(entries, results, false))
|
||||
|
||||
before := teamDimensionDump(without)
|
||||
after := teamDimensionDump(with)
|
||||
if before != after {
|
||||
t.Fatalf("挂上队员后单位维度变了：\n之前\n%s之后\n%s", before, after)
|
||||
}
|
||||
if !strings.Contains(before, "单位榜") || !strings.Contains(before, "单位奖牌榜") {
|
||||
t.Fatalf("对拍文本里必须有单位榜与单位奖牌榜，否则等于两份空文本相等：\n%s", before)
|
||||
}
|
||||
// 防空转：老形态的个人维度确实是空的（队员认不出来就上不了个人榜）。
|
||||
if got := len(BuildAthleteStandings(StandingsInput{Ledger: without.Ledger, Ranked: without.Ranked})); got != 0 {
|
||||
t.Fatalf("没有队员关联时个人榜应为空，得到 %d 行", got)
|
||||
}
|
||||
if got := len(BuildAthleteStandings(StandingsInput{Ledger: with.Ledger, Ranked: with.Ranked})); got != 2 {
|
||||
t.Fatalf("挂上队员后个人榜应有两个队员，得到 %d 行", got)
|
||||
}
|
||||
}
|
||||
|
||||
// teamDimensionDump 把「单位维度」的全部事实拼成稳定文本：单位那一份流水、单位总分、
|
||||
// 单位榜与单位奖牌榜。队员的个人流水不进这份文本（它不属于单位维度）。
|
||||
func teamDimensionDump(es EventScore) string {
|
||||
var lines []string
|
||||
for _, l := range es.Ledger {
|
||||
if l.AthleteID != 0 {
|
||||
continue
|
||||
}
|
||||
lines = append(lines, fmt.Sprintf("流水 team=%d entry=%d result=%d points=%v countToTeam=%v",
|
||||
l.TeamID, l.EntryID, l.ResultID, l.Points, l.CountToTeam))
|
||||
}
|
||||
for _, rr := range es.Ranked {
|
||||
if rr.AthleteID != 0 {
|
||||
continue
|
||||
}
|
||||
lines = append(lines, fmt.Sprintf("名次 key=%s scope=%s team=%d rank=%d points=%v shares=%s",
|
||||
rr.SubjectKey, rr.Scope, rr.TeamID, rr.Rank, rr.Points, formatShares(rr.Shares)))
|
||||
}
|
||||
in := StandingsInput{Teams: testTeams(1001, 1002), Ledger: es.Ledger, Ranked: es.Ranked}
|
||||
for _, weight := range []float64{1, 0.5} {
|
||||
for _, exclude := range []bool{false, true} {
|
||||
for _, row := range BuildTeamStandings(StandingsInput{
|
||||
Teams: in.Teams, Ledger: in.Ledger, Ranked: in.Ranked,
|
||||
IndividualToTeamWeight: weight, ExcludeTeamEventMedals: exclude,
|
||||
}) {
|
||||
lines = append(lines, fmt.Sprintf("单位榜 w=%v ex=%v team=%d pts=%v only=%v indiv=%v %d/%d/%d",
|
||||
weight, exclude, row.TeamID, row.Points, row.TeamOnlyPoints, row.IndividualPoints,
|
||||
row.Gold, row.Silver, row.Bronze))
|
||||
}
|
||||
for _, row := range BuildMedalStandings(StandingsInput{
|
||||
Teams: in.Teams, Ledger: in.Ledger, Ranked: in.Ranked,
|
||||
IndividualToTeamWeight: weight, ExcludeTeamEventMedals: exclude,
|
||||
}) {
|
||||
lines = append(lines, fmt.Sprintf("单位奖牌榜 w=%v ex=%v team=%d %d/%d/%d total=%d",
|
||||
weight, exclude, row.TeamID, row.Gold, row.Silver, row.Bronze, row.Total))
|
||||
}
|
||||
}
|
||||
}
|
||||
return strings.Join(lines, "\n") + "\n"
|
||||
}
|
||||
|
||||
// rankedSummary 打印名次明细里「谁、什么名次、多少分」这几件事。
|
||||
func rankedSummary(ranked []RankedResult) []string {
|
||||
out := make([]string, 0, len(ranked))
|
||||
for _, rr := range ranked {
|
||||
out = append(out, fmt.Sprintf("key=%s scope=%s basis=%s team=%d athlete=%d rank=%d points=%v",
|
||||
rr.SubjectKey, rr.Scope, rr.Basis, rr.TeamID, rr.AthleteID, rr.Rank, rr.Points))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// ledgerSummary 打印流水的归属与是否计入单位总分。
|
||||
func ledgerSummary(ledger []LedgerEntry) []string {
|
||||
out := make([]string, 0, len(ledger))
|
||||
for _, l := range ledger {
|
||||
out = append(out, fmt.Sprintf("team=%d athlete=%d entry=%d result=%d points=%v countToTeam=%v",
|
||||
l.TeamID, l.AthleteID, l.EntryID, l.ResultID, l.Points, l.CountToTeam))
|
||||
}
|
||||
return out
|
||||
}
|
||||
@@ -84,6 +84,8 @@ type participant struct {
|
||||
state ResultState
|
||||
// shares 是联队份额（多个单位共享一条成绩）；留空 = 主单位独占 100%。
|
||||
shares []TeamShare
|
||||
// members 是团体报名的队员（团队项目的成员运动员）；留空 = 只报单位（老数据）。
|
||||
members []EntryAthlete
|
||||
}
|
||||
|
||||
func fixture(ps []participant) ([]Entry, []Result) {
|
||||
@@ -93,7 +95,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, TeamShares: p.shares,
|
||||
Status: p.entryStatus, TeamShares: p.shares, Athletes: p.members,
|
||||
})
|
||||
state := p.state
|
||||
if state == "" {
|
||||
|
||||
@@ -69,6 +69,14 @@ type RankedResult struct {
|
||||
AwardMedals bool
|
||||
CountToMedals bool
|
||||
CountToTeamMedals bool
|
||||
// MemberCopy 为 true 表示这条名次是「团体报名的队员各拿一份」的个人副本（devdocs/20）：
|
||||
// 分记到 AthleteID 头上（个人榜），但**不进单位维度**——流水恒为 count_to_team=false，
|
||||
// 单位奖牌按报名项去重时也只认报名项那一份。
|
||||
//
|
||||
// 它只在「引擎产出 → 落库」这一段有意义：channel_ranks 不存这个开关，落库后认出这些行
|
||||
// 靠 subject_key 的 'e:<报名项>:a:<运动员>' 形状与 athlete_id 关联，而下游（榜单、导出、
|
||||
// 快照）本来就不需要它——它们看的是「按报名项去重」与 athlete_id 这两件既有事实。
|
||||
MemberCopy bool
|
||||
}
|
||||
|
||||
// ScoreEvent 按项目的计分通道逐条计算名次与积分，输出流水与名次明细。
|
||||
@@ -430,12 +438,65 @@ func rankGroups(in EventScoreInput, ch ScoreChannel, profile ScoringProfile, gro
|
||||
for _, g := range groups {
|
||||
pts := groupPoints(profile, g.startRank, len(g.members), lastPlace, in.Event, in.Category)
|
||||
for _, c := range g.members {
|
||||
out = append(out, rankedResult(in, ch, c, g.startRank, pts))
|
||||
out = append(out, entryRankedResults(in, ch, c, g.startRank, pts)...)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// entryRankedResults 产出一条报名的**全部**名次明细：第一条是报名项自己那份（单位维度只认它，
|
||||
// 老数据也只有这一条），后面是每个队员的个人副本（团队报名才有，每人一份完整的个人分）。
|
||||
//
|
||||
// 顺序是有意的：报名项那一份排在最前。channel_ranks 按 (…, 名次, id) 读出、奖牌去重按报名项
|
||||
// 取同键里的第一条，于是「单位维度读到的是哪一份」与升级前完全一致。
|
||||
func entryRankedResults(in EventScoreInput, ch ScoreChannel, c candidate, rank int, points float64) []RankedResult {
|
||||
base := rankedResult(in, ch, c, rank, points)
|
||||
members := memberAthletes(ch, c.entry)
|
||||
if len(members) == 0 {
|
||||
return []RankedResult{base}
|
||||
}
|
||||
out := make([]RankedResult, 0, len(members)+1)
|
||||
out = append(out, base)
|
||||
for _, m := range members {
|
||||
out = append(out, memberCopy(base, m))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// memberAthletes 判断这条名次要不要给队员各发一份：只有**个人通道**（scope=athlete）才发。
|
||||
// 团体通道（scope=team）的名次本来就记在单位头上，队员不参与；带运动员的报名（个人报名）
|
||||
// 自己就是那个人的身份，没有队员这回事。
|
||||
func memberAthletes(ch ScoreChannel, e Entry) []EntryAthlete {
|
||||
if ch.Scope != ScopeAthlete || e.AthleteID != 0 {
|
||||
return nil
|
||||
}
|
||||
return e.Athletes
|
||||
}
|
||||
|
||||
// memberCopy 把「报名项那一份名次」复制成某个队员的个人分：分数、名次、归属单位与份额全部照抄，
|
||||
// 只把身份换成这个队员，并打上 MemberCopy 标记（落库时按它走「只记个人」的流水）。
|
||||
//
|
||||
// 照抄 TeamID 与 Shares 是**必须的**：单位维度按报名项去重（standings.medalKeyOf），
|
||||
// 无论同键里的哪一份胜出，单位拿到的分与牌都是同一份；换成队员自己的单位或另造份额，
|
||||
// 就会在「谁在去重里胜出」这件事上分叉，联队报名尤其容易给错单位记牌。
|
||||
func memberCopy(base RankedResult, m EntryAthlete) RankedResult {
|
||||
cp := base
|
||||
cp.MemberCopy = true
|
||||
cp.AthleteID = m.AthleteID
|
||||
cp.AthleteName = m.Name
|
||||
cp.SubjectKey = memberSubjectKey(base.EntryID, m.AthleteID)
|
||||
return cp
|
||||
}
|
||||
|
||||
// memberSubjectKey 是队员个人副本的主体标识：'e:<报名项>:a:<运动员>'。
|
||||
//
|
||||
// 必须带上报名项：同一个运动员可以同时出现在同组别的两条报名里（例如一个单位的一队与二队
|
||||
// 各带了他），只用 'a:<运动员>' 会撞 channel_ranks 的 (通道, 组别, 主体) 唯一索引，
|
||||
// 整次发布直接 500。既有名次键（e: / a: / t: / ch:）一个字符都没变，老行不受影响。
|
||||
func memberSubjectKey(entryID, athleteID int64) string {
|
||||
return fmt.Sprintf("e:%d:a:%d", entryID, athleteID)
|
||||
}
|
||||
|
||||
// groupPoints 计算一组并列者拿到的分。
|
||||
// 三种口径都先确定这组「占用了哪些名次」：startRank .. startRank+size-1；
|
||||
// lastPlace 是本组别被占用的最大名次档（末位那一档，skip 口径下等于实际可排名人数 N）。
|
||||
@@ -684,6 +745,9 @@ func validResultValue(r Result, found bool, opts ScoreOptions) (float64, bool) {
|
||||
// 0 分不产生流水，避免流水表被零分噪声撑大。
|
||||
// 流水是否计入单位总分由通道的 countToTeam 决定（个人通道可以只记个人）。
|
||||
//
|
||||
// 队员的个人副本走另一条路（memberLedger）：每个队员一整份分、只记个人（count_to_team=false），
|
||||
// 于是单位总分与单位奖牌一个字节都不动——那是本单最容易错的地方，见 memberLedger。
|
||||
//
|
||||
// 团体手工名次与聚合名次没有对应的报名项与成绩（EntryID=0、ResultID=0），
|
||||
// 仍要能落库：SourceType 与聚合流水一样是 result，sourceID 退化为通道 id，
|
||||
// 由真实来源（通道 + 主体）唯一确定。写入侧按「EntryID=0 && ResultID=0 && source_type=result」
|
||||
@@ -694,10 +758,6 @@ func ledgerFromRanked(in EventScoreInput, ch ScoreChannel, ranked []RankedResult
|
||||
if rr.Points == 0 {
|
||||
continue
|
||||
}
|
||||
athleteID := int64(0)
|
||||
if rr.Scope == ScopeAthlete {
|
||||
athleteID = rr.AthleteID
|
||||
}
|
||||
sourceID := rr.ResultID
|
||||
if sourceID == 0 {
|
||||
sourceID = rr.EntryID
|
||||
@@ -705,6 +765,14 @@ func ledgerFromRanked(in EventScoreInput, ch ScoreChannel, ranked []RankedResult
|
||||
if sourceID == 0 {
|
||||
sourceID = ch.ID
|
||||
}
|
||||
if rr.MemberCopy {
|
||||
out = append(out, memberLedger(rr, in, ch, sourceID))
|
||||
continue
|
||||
}
|
||||
athleteID := int64(0)
|
||||
if rr.Scope == ScopeAthlete {
|
||||
athleteID = rr.AthleteID
|
||||
}
|
||||
split := splitSharePoints(rr.Points, rr.Shares)
|
||||
for i, s := range rr.Shares {
|
||||
if split[i] == 0 {
|
||||
@@ -728,6 +796,29 @@ func ledgerFromRanked(in EventScoreInput, ch ScoreChannel, ranked []RankedResult
|
||||
return out
|
||||
}
|
||||
|
||||
// memberLedger 是队员个人副本的流水：**只记个人**（CountToTeam 恒为 false），
|
||||
// 每个队员一整份分，不按份额拆（联队那套是「拆」，这里是「复制」，别抄混）。
|
||||
//
|
||||
// 为什么恒为 false、而不是照抄通道开关：单位维度只认报名项那一份流水（它照抄通道开关），
|
||||
// 队员这两份若也计入，单位总分就会变成 N 份（双打就是双倍），单位奖牌同理。
|
||||
// SumByTeam 遇到 count_to_team=0 直接跳过，所以单位总分、单位明细、单位奖牌全都不会看到它们；
|
||||
// 而 SumByAthlete 不看这个开关，队员的个人分照拿（这也正是「双打不进单位、但上个人榜」的实现）。
|
||||
func memberLedger(rr RankedResult, in EventScoreInput, ch ScoreChannel, sourceID int64) LedgerEntry {
|
||||
return LedgerEntry{
|
||||
TeamID: rr.TeamID,
|
||||
AthleteID: rr.AthleteID,
|
||||
EventID: in.Event.ID,
|
||||
CategoryID: in.Category.ID,
|
||||
EntryID: rr.EntryID,
|
||||
ResultID: rr.ResultID,
|
||||
ChannelID: ch.ID,
|
||||
SourceType: SourceResult,
|
||||
SourceID: sourceID,
|
||||
Points: rr.Points,
|
||||
CountToTeam: false,
|
||||
}
|
||||
}
|
||||
|
||||
// subjectKeyOf 计算一条名次明细的主体标识（channel_ranks.subject_key 同口径）：
|
||||
// 有报名项就用报名项（个人名次按报名项去重才不会被并列拆开），否则按主体（个人 / 单位），
|
||||
// 全为空时退化为通道 id，保证 (通道, 组别, 主体) 的唯一索引不会撞键。
|
||||
|
||||
@@ -298,9 +298,12 @@ func medalKeyOf(rr RankedResult, index int) medalKey {
|
||||
return k
|
||||
}
|
||||
|
||||
// pickMedalChannels 先按奖牌入选判据过滤，再把按通道展开的名次明细去重成「每个主体一条」：
|
||||
// pickMedalChannels 先按奖牌入选判据过滤，再把按通道展开的名次明细按 keyOf 去重成「每个主体一条」：
|
||||
// 只保留优先级最高的通道名次（个人通道优先），否则双通道项目一条成绩会拿两枚奖牌。
|
||||
func pickMedalChannels(ranked []RankedResult, excludeTeam bool) []RankedResult {
|
||||
//
|
||||
// 去重键由调用方给：**单位维度按报名项**（medalKeyOf，一条报名只记一枚牌），
|
||||
// **个人维度按报名项 + 运动员**（athleteMedalKeyOf，团体报名的队员各记各的）。
|
||||
func pickMedalChannels(ranked []RankedResult, excludeTeam bool, keyOf func(RankedResult, int) medalKey) []RankedResult {
|
||||
best := make(map[medalKey]RankedResult, len(ranked))
|
||||
order := make([]medalKey, 0, len(ranked))
|
||||
for i, rr := range ranked {
|
||||
@@ -310,7 +313,7 @@ func pickMedalChannels(ranked []RankedResult, excludeTeam bool) []RankedResult {
|
||||
if excludeTeam && rr.Scope == ScopeTeam {
|
||||
continue
|
||||
}
|
||||
k := medalKeyOf(rr, i)
|
||||
k := keyOf(rr, i)
|
||||
cur, ok := best[k]
|
||||
if !ok {
|
||||
best[k] = rr
|
||||
@@ -328,10 +331,31 @@ func pickMedalChannels(ranked []RankedResult, excludeTeam bool) []RankedResult {
|
||||
return out
|
||||
}
|
||||
|
||||
// athleteMedalKeyOf 是个人维度的奖牌去重键：在单位维度的键上再带上运动员。
|
||||
//
|
||||
// 团体报名的队员各有一份个人副本，它们与报名项那一份共享 entry_id——只按报名项去重的话，
|
||||
// 三份会并成一条（且胜出的是排在最前的报名项那份，AthleteID=0，个人维度根本不看它），
|
||||
// 队员的个人奖牌会**一枚都发不出来**。带上运动员之后：同一报名项同一运动员仍旧只记一枚
|
||||
// （多通道项目不会重复发牌），不同队员各记各的。
|
||||
//
|
||||
// 只对「有报名项」的名次加这一维：没有报名项的聚合名次本来就用主体区分（medalKeyOf 已处理），
|
||||
// 老数据的名次构不成同一个键下的多条，行为逐字节不变。
|
||||
func athleteMedalKeyOf(rr RankedResult, index int) medalKey {
|
||||
k := medalKeyOf(rr, index)
|
||||
if k.entryID != 0 && rr.AthleteID != 0 {
|
||||
k.scope, k.subject = ScopeAthlete, rr.AthleteID
|
||||
}
|
||||
return k
|
||||
}
|
||||
|
||||
// teamMedals 统计单位奖牌榜。按 Shares 逐份额记牌：每个份额各记**一枚整牌**，
|
||||
// 联队拿到的金牌因此两个成员单位各记 1 枚（不是各 0.5 枚，口径见 TeamShare.Medal）。
|
||||
// 份额里的 Medal 显式关掉时该单位不记这枚牌（积分份额 Weight 不参与奖牌计算）。
|
||||
//
|
||||
// 去重按**报名项**（medalKeyOf）：一条报名在同一小项同一组别只记一枚牌，而团体报名的队员
|
||||
// 个人副本与报名项那一份共享 entry_id，因此**不会把单位奖牌数放大成队员人数倍**
|
||||
// ——这是本单最容易错的地方，由 TestTeamEntryMembersKeepTeamDimensionByteIdentical 钉住。
|
||||
//
|
||||
// 两层开关（devdocs 17 §4.5）：
|
||||
// - 粗粒度总闸 StandingsInput.ExcludeTeamEventMedals：为 true 时团体项目的奖牌一律不进单位榜；
|
||||
// - 通道开关 count_to_team_medals：scope=athlete 的通道置 false 时，它的个人奖牌不进单位榜。
|
||||
@@ -339,7 +363,7 @@ func pickMedalChannels(ranked []RankedResult, excludeTeam bool) []RankedResult {
|
||||
// 两者是「与」的关系；scope=team 的奖牌本来就记在单位头上，不受通道开关影响。
|
||||
func teamMedals(in StandingsInput) map[int64]medalTally {
|
||||
out := make(map[int64]medalTally)
|
||||
for _, rr := range pickMedalChannels(in.Ranked, in.ExcludeTeamEventMedals) {
|
||||
for _, rr := range pickMedalChannels(in.Ranked, in.ExcludeTeamEventMedals, medalKeyOf) {
|
||||
if rr.Scope != ScopeTeam && !rr.CountToTeamMedals {
|
||||
continue
|
||||
}
|
||||
@@ -368,9 +392,12 @@ func teamMedals(in StandingsInput) map[int64]medalTally {
|
||||
|
||||
// athleteMedals 只统计个人项目（scope=athlete）的奖牌；
|
||||
// 通道的 count_to_team_medals 与个人榜无关，只决定这枚奖牌算不算进单位榜。
|
||||
//
|
||||
// 去重按**报名项 + 运动员**（athleteMedalKeyOf）：团体报名的每个队员各记一枚自己的奖牌
|
||||
// （他们共享同一条报名项，只按报名项去重会把队员的奖牌并成一枚、甚至一枚都不发）。
|
||||
func athleteMedals(in StandingsInput) map[int64]medalTally {
|
||||
out := make(map[int64]medalTally)
|
||||
for _, rr := range pickMedalChannels(in.Ranked, false) {
|
||||
for _, rr := range pickMedalChannels(in.Ranked, false, athleteMedalKeyOf) {
|
||||
if rr.Scope != ScopeAthlete || rr.AthleteID == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
@@ -311,6 +311,18 @@ func (s TeamShare) CountsMedal() bool {
|
||||
return s.Medal == nil || *s.Medal
|
||||
}
|
||||
|
||||
// EntryAthlete 是团体报名里的一名队员（团队成员），身份靠运动员档案（AthleteID）确立；
|
||||
// 人工认人时以**号码布**为准（姓名会重名，号码布不会，见迁移 0014 与 devdocs/20）。
|
||||
//
|
||||
// 与 TeamShare 对称但语义**相反**（devdocs/20 §二）：TeamShare 是「一条报名 → 多个单位、
|
||||
// 按权重**拆**分」，EntryAthlete 是「一条报名 → 多个运动员、每人各拿**整份**分」。
|
||||
// 抄联队那套「拆」会把双打两个人的分各砍一半，这正是本单最容易抄错的地方。
|
||||
type EntryAthlete struct {
|
||||
AthleteID int64 `json:"athleteId"`
|
||||
// Name 是冗余姓名，与 Entry.AthleteName 同一个用途：引擎不必回查库就能产出个人榜的那一行。
|
||||
Name string `json:"name,omitempty"`
|
||||
}
|
||||
|
||||
// Entry 报名项：某单位派某人/某队参加某小项。TeamID 是**主单位**（联队时也保留它，
|
||||
// 报名项的唯一键、榜单兜底、导入去重都还认这一个），联队的其余成员单位在 TeamShares 里。
|
||||
type Entry struct {
|
||||
@@ -328,6 +340,10 @@ type Entry struct {
|
||||
// TeamShares 是这条报名的归属份额配置：空 = 主单位独占 100%（老数据、普通报名），
|
||||
// 多条 = 联队。引擎只读不改，取分的唯一入口是 ResolveShares。
|
||||
TeamShares []TeamShare `json:"teamShares,omitempty"`
|
||||
// Athletes 是这条报名的队员（团队 / 对抗项目的成员），空 = 只报单位（升级前的老数据、
|
||||
// 以及「人没录档案只登记姓名」的降级形态）。只对纯团体报名（AthleteID == 0）有意义。
|
||||
// 队员各拿一份完整的个人分与个人奖牌；单位维度仍然只算这条报名一次。
|
||||
Athletes []EntryAthlete `json:"athletes,omitempty"`
|
||||
}
|
||||
|
||||
// Result 成绩；一条报名项一条成绩。
|
||||
|
||||
Reference in new issue
Block a user