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 成绩；一条报名项一条成绩。
|
||||
|
||||
@@ -156,7 +156,11 @@ func LoadAthleteDetailWorkbook(db *sql.DB, opts Options) (AthleteDetailWorkbook,
|
||||
if err != nil {
|
||||
return AthleteDetailWorkbook{}, err
|
||||
}
|
||||
rows, err := loadAthleteDetailRows(db)
|
||||
joints, err := loadJointTeams(db)
|
||||
if err != nil {
|
||||
return AthleteDetailWorkbook{}, err
|
||||
}
|
||||
rows, err := loadAthleteDetailRows(db, joints)
|
||||
if err != nil {
|
||||
return AthleteDetailWorkbook{}, err
|
||||
}
|
||||
@@ -208,7 +212,7 @@ const athleteDetailRankExpr = `COALESCE((
|
||||
ORDER BY CASE WHEN ch.scope = 'athlete' THEN 0 ELSE 1 END, ch.sort_order, ch.id, cr.id
|
||||
LIMIT 1), COALESCE(r.rank, 0))`
|
||||
|
||||
func loadAthleteDetailRows(db *sql.DB) ([]AthleteDetailRow, error) {
|
||||
func loadAthleteDetailRows(db *sql.DB, joints map[int64]jointTeam) ([]AthleteDetailRow, error) {
|
||||
// 聚合流水的组别回推与单位明细同一条思路：某个运动员在本小项只参加了一个组别时，那个组别就是答案；
|
||||
// 多个组别时回推不出来，宁可留空也不猜（回推只对 entry_id / result_id 都为空的聚合流水生效）。
|
||||
rows, err := db.Query(`
|
||||
@@ -217,7 +221,7 @@ func loadAthleteDetailRows(db *sql.DB) ([]AthleteDetailRow, error) {
|
||||
` + athleteDetailRankExpr + `, COALESCE(r.result_text, ''), COALESCE(r.unit, ''),
|
||||
l.points, l.source_type,
|
||||
COALESCE(s.sort_order, 0), COALESCE(e.sort_order, 0), COALESCE(c.sort_order, ca.sort_order, 0),
|
||||
COALESCE(l.event_id, 0), COALESCE(c.id, ca.id, 0), l.id
|
||||
COALESCE(l.event_id, 0), COALESCE(c.id, ca.id, 0), l.id, COALESCE(l.entry_id, 0)
|
||||
FROM score_ledger l
|
||||
LEFT JOIN athletes a ON a.id = l.athlete_id
|
||||
LEFT JOIN events e ON e.id = l.event_id
|
||||
@@ -247,16 +251,23 @@ func loadAthleteDetailRows(db *sql.DB) ([]AthleteDetailRow, error) {
|
||||
source string
|
||||
resultText string
|
||||
unit string
|
||||
entryID int64
|
||||
)
|
||||
if err := rows.Scan(&row.teamID, &row.AthleteName,
|
||||
&row.SportName, &row.EventName, &row.Category,
|
||||
&row.Rank, &resultText, &unit, &row.Points, &source,
|
||||
&row.sportSort, &row.eventSort, &row.catSort,
|
||||
&row.eventID, &row.categoryID, &row.ledgerID); err != nil {
|
||||
&row.eventID, &row.categoryID, &row.ledgerID, &entryID); err != nil {
|
||||
return nil, fmt.Errorf("export: 扫描个人得分明细: %w", err)
|
||||
}
|
||||
row.ResultText = displayResult(resultText, unit)
|
||||
row.Source = sourceLabel(source)
|
||||
// 联队说明挂在「来源」列：这张表没有备注列，而「来源」写的正是这一分是从哪来的
|
||||
//（成绩 / 破纪录加分 / 人工调整）。联队的一条成绩会给每个成员单位各留一行流水，
|
||||
// 不写这一句，读表的人只会看到同一个人在同一小项出现了两次、每次半份分。
|
||||
if joint, ok := joints[entryID]; ok {
|
||||
row.Source += "（" + joint.shareNote() + "）"
|
||||
}
|
||||
out = append(out, row)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
|
||||
@@ -123,13 +123,18 @@ func LoadEntriesWorkbook(db *sql.DB, filter EntriesFilter, opts Options) (Entrie
|
||||
if err != nil {
|
||||
return EntriesWorkbook{}, err
|
||||
}
|
||||
// 联队配置：导出名单里的单位编码回写成导入表的 A+B 写法，单位名写全成员，备注里写清份额。
|
||||
joints, err := loadJointTeams(db)
|
||||
if err != nil {
|
||||
return EntriesWorkbook{}, err
|
||||
}
|
||||
|
||||
query := `
|
||||
SELECT COALESCE(ev.code, ''), COALESCE(ev.name, ''), COALESCE(c.name, ''),
|
||||
COALESCE(t.code, ''), COALESCE(t.name, ''),
|
||||
COALESCE(a.name, ''), COALESCE(en.member_names, ''),
|
||||
COALESCE(a.id_card, ''), COALESCE(en.bib, ''), en.heat,
|
||||
COALESCE(a.gender, ''), a.age, en.status, COALESCE(en.remark, '')
|
||||
COALESCE(a.gender, ''), a.age, en.status, COALESCE(en.remark, ''), en.id
|
||||
FROM entries en
|
||||
JOIN events ev ON ev.id = en.event_id
|
||||
JOIN teams t ON t.id = en.team_id
|
||||
@@ -145,7 +150,6 @@ func LoadEntriesWorkbook(db *sql.DB, filter EntriesFilter, opts Options) (Entrie
|
||||
}{
|
||||
{"en.event_id", filter.EventID},
|
||||
{"en.category_id", filter.CategoryID},
|
||||
{"en.team_id", filter.TeamID},
|
||||
{"en.heat", filter.Heat},
|
||||
} {
|
||||
if f.value != 0 {
|
||||
@@ -153,6 +157,24 @@ func LoadEntriesWorkbook(db *sql.DB, filter EntriesFilter, opts Options) (Entrie
|
||||
args = append(args, f.value)
|
||||
}
|
||||
}
|
||||
// 单位筛选要连「联队里的成员单位」一起算：entries.team_id 只是主单位（加号左边那个），
|
||||
// 但成员单位同样在这条报名上拿分拿牌——按 B 导出时看不到它，B 就不知道自己派了谁上场。
|
||||
// 主单位那一半条件照旧留着：份额行缺失的报名（手工造的老数据）不能因此从筛选结果里掉出去。
|
||||
// 份额表不在（库还没跑到 0024）时不加这段：那种库里根本没有联队。
|
||||
if filter.TeamID != 0 {
|
||||
teamCond := "en.team_id = ?"
|
||||
args = append(args, filter.TeamID)
|
||||
ready, err := entrySharesReady(db)
|
||||
if err != nil {
|
||||
return EntriesWorkbook{}, err
|
||||
}
|
||||
if ready {
|
||||
teamCond += ` OR EXISTS (SELECT 1 FROM entry_team_shares s
|
||||
WHERE s.entry_id = en.id AND s.team_id = ?)`
|
||||
args = append(args, filter.TeamID)
|
||||
}
|
||||
conds = append(conds, "("+teamCond+")")
|
||||
}
|
||||
if len(conds) > 0 {
|
||||
query += " WHERE " + strings.Join(conds, " AND ")
|
||||
}
|
||||
@@ -176,10 +198,11 @@ func LoadEntriesWorkbook(db *sql.DB, filter EntriesFilter, opts Options) (Entrie
|
||||
heat sql.NullInt64
|
||||
age sql.NullInt64
|
||||
athleteName string
|
||||
entryID int64
|
||||
)
|
||||
if err := rows.Scan(&row.EventCode, &row.EventName, &row.Category, &row.TeamCode, &row.TeamName,
|
||||
&athleteName, &memberJSON, &row.IDCard, &row.Bib, &heat,
|
||||
&row.Gender, &age, &row.Status, &row.Remark); err != nil {
|
||||
&row.Gender, &age, &row.Status, &row.Remark, &entryID); err != nil {
|
||||
return EntriesWorkbook{}, fmt.Errorf("export: 扫描报名名单: %w", err)
|
||||
}
|
||||
row.Name = participantName(athleteName, memberJSON)
|
||||
@@ -192,6 +215,13 @@ func LoadEntriesWorkbook(db *sql.DB, filter EntriesFilter, opts Options) (Entrie
|
||||
row.Age = ""
|
||||
}
|
||||
row.Status = entryExportStatusLabel(row.Status)
|
||||
// 联队：单位编码回写成 A+B（这份名单能直接拿去重导），单位名写全成员，
|
||||
// 备注里写清这条分拆给了哪几个单位、各占多少。报名名单没有积分列，只写份额比例。
|
||||
if joint, ok := joints[entryID]; ok {
|
||||
row.TeamCode = joint.Code()
|
||||
row.TeamName = joint.Name()
|
||||
row.Remark = appendNote(row.Remark, joint.shareRatioNote())
|
||||
}
|
||||
out = append(out, row)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
|
||||
@@ -0,0 +1,260 @@
|
||||
package export
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"math"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// 本文件是「联队 + 份额分成」（devdocs/19）在导出侧的读法。
|
||||
//
|
||||
// 一条报名配了多个成员单位时（现场有两个单位因人数不足合并参赛），导出件要做两件事：
|
||||
// - 把联队的名字写出来，**成员单位名写全**，形如「第一分公司+第二分公司联队」；
|
||||
// - 讲清这条分拆给了哪几个单位、各多少（份额比例 + 各单位实得积分）。
|
||||
//
|
||||
// 两个口径必须分开（已拍板，见 domain.TeamShare）：积分按份额拆（允许 0.5 分），
|
||||
// 奖牌**每个成员单位各记一枚整枚**。后者会让「各单位的奖牌数加起来」大于实际颁发的奖牌数，
|
||||
// 那是定稿口径、不是 bug，所以联队奖牌那一格自己要把「各单位各记 1 枚」写出来，
|
||||
// 含联队的榜单类导出件另在副标题里写一句口径说明（见 jointMedalNote）。
|
||||
|
||||
// jointMedalNote 是含联队的榜单类导出件（总表 / 单位奖牌明细）副标题上的口径说明。
|
||||
// 奖牌数之和会大于实际颁发数是定稿口径（每个成员单位各记一整枚），
|
||||
// 不说这一句，拿导出件对账的人会以为多印了奖牌。
|
||||
const jointMedalNote = "注：本赛事含联队，奖牌按「每个成员单位各记 1 枚」统计，各单位奖牌数之和会大于实际颁发数"
|
||||
|
||||
// jointMember 是联队里的一个成员单位：展示字段 + 份额 + 本单位实得积分。
|
||||
type jointMember struct {
|
||||
TeamID int64
|
||||
Code string
|
||||
// Name 是单位全称（缺全称时退简称）——现场看的就是这个，不能用编码凑合。
|
||||
Name string
|
||||
Weight float64
|
||||
// CountsMedal 为 false 时这枚奖牌不记给本单位（缺省 true = 整枚各记）。
|
||||
CountsMedal bool
|
||||
// Points 是本单位从这条成绩实得的积分（按流水统计：引擎已按份额拆好；没出分前是 0）。
|
||||
Points float64
|
||||
// Primary 标记这是报名的主单位（entries.team_id）：显示名与导出的编码都以它打头。
|
||||
Primary bool
|
||||
}
|
||||
|
||||
// jointTeam 是一条报名配的联队：成员单位按份额顺序（主单位排第一），至少两个。
|
||||
type jointTeam struct {
|
||||
members []jointMember
|
||||
}
|
||||
|
||||
// Name 是联队的显示名：成员单位名写全，用 + 连起来再加「联队」——「第一分公司+第二分公司联队」。
|
||||
// 写法与导入表 team_code 的 `A+B` 同构，现场拿着一份表能一眼对上另一份。
|
||||
func (t jointTeam) Name() string {
|
||||
names := make([]string, 0, len(t.members))
|
||||
for _, m := range t.members {
|
||||
names = append(names, m.Name)
|
||||
}
|
||||
return strings.Join(names, "+") + "联队"
|
||||
}
|
||||
|
||||
// Code 是联队的单位编码：`T1+T2`，与导入表的 team_code 写法逐字一致，
|
||||
// 于是导出的报名名单可以直接拿去重导（round-trip），不必手工改回单单位。
|
||||
func (t jointTeam) Code() string {
|
||||
codes := make([]string, 0, len(t.members))
|
||||
for _, m := range t.members {
|
||||
codes = append(codes, m.Code)
|
||||
}
|
||||
return strings.Join(codes, "+")
|
||||
}
|
||||
|
||||
// shareRatioNote 是只讲份额的说明：「联队分拆：第一分公司 50%、第二分公司 50%」。
|
||||
// 报名名单用它：那张表是报名侧的数据（号码布 / 批次 / 状态），没有积分列，
|
||||
// 凭空冒出「5 分」反而让人以为这里也在算分。
|
||||
func (t jointTeam) shareRatioNote() string {
|
||||
return "联队分拆：" + strings.Join(t.shareItems(false), "、")
|
||||
}
|
||||
|
||||
// shareNote 是份额说明：「联队分拆：第一分公司 7.5 分（50%）、第二分公司 7.5 分（50%）」。
|
||||
//
|
||||
// 已经出分（成员里有非零积分）时把各单位的实得积分一并写出来——「各多少」问的就是它，
|
||||
// 而导出件上的「积分」列只写了联队拿到的总分。还没出分时退化成只写份额比例。
|
||||
func (t jointTeam) shareNote() string {
|
||||
return "联队分拆：" + strings.Join(t.shareItems(true), "、")
|
||||
}
|
||||
|
||||
// shareItems 拼各成员单位的份额描述，顺序与份额一致（主单位在前）。
|
||||
func (t jointTeam) shareItems(withPoints bool) []string {
|
||||
sum := 0.0
|
||||
for _, m := range t.members {
|
||||
sum += shareWeightOf(m.Weight)
|
||||
}
|
||||
if withPoints {
|
||||
withPoints = false
|
||||
for _, m := range t.members {
|
||||
if m.Points != 0 {
|
||||
withPoints = true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
items := make([]string, 0, len(t.members))
|
||||
for _, m := range t.members {
|
||||
percent := formatPercent(shareWeightOf(m.Weight), sum)
|
||||
if withPoints {
|
||||
items = append(items, fmt.Sprintf("%s %s 分（%s）", m.Name, formatPoints(m.Points), percent))
|
||||
continue
|
||||
}
|
||||
items = append(items, m.Name+" "+percent)
|
||||
}
|
||||
return items
|
||||
}
|
||||
|
||||
// medalCell 把一枚联队奖牌写全：「金牌（联队 第一分公司+第二分公司，各单位各记 1 枚）」。
|
||||
//
|
||||
// 括注必须留在奖牌这一格：奖牌明细里非联队行只有「金牌」两个字，读者把各单位的奖牌数加起来
|
||||
// 会比实际颁发的多（口径如此），这一句就是给那个数字的解释。有成员被显式关掉记牌时改写成
|
||||
// 「记给 甲、乙」——那种写法现在只有改份额的接口做得出来，但照样不能让人猜。
|
||||
func (t jointTeam) medalCell(medal string) string {
|
||||
all := make([]string, 0, len(t.members))
|
||||
counting := make([]string, 0, len(t.members))
|
||||
for _, m := range t.members {
|
||||
all = append(all, m.Name)
|
||||
if m.CountsMedal {
|
||||
counting = append(counting, m.Name)
|
||||
}
|
||||
}
|
||||
if len(counting) == len(all) {
|
||||
return fmt.Sprintf("%s（联队 %s，各单位各记 1 枚）", medal, strings.Join(all, "+"))
|
||||
}
|
||||
return fmt.Sprintf("%s（联队 %s，记给 %s）", medal, strings.Join(all, "+"), strings.Join(counting, "、"))
|
||||
}
|
||||
|
||||
// shareWeightOf 与引擎的 shareWeight 同一口径：0 与负数按 1 处理（份额是相对权重，不填即均分）。
|
||||
func shareWeightOf(weight float64) float64 {
|
||||
if weight <= 0 {
|
||||
return 1
|
||||
}
|
||||
return weight
|
||||
}
|
||||
|
||||
// formatPercent 把份额写成占比（weight / Σweight）：1+1 → 50%、2:1 → 66.7% / 33.3%。
|
||||
// 保留一位小数并去掉多余的 0：现场看的是一眼能懂的比例，不是浮点数的原貌。
|
||||
func formatPercent(weight, sum float64) string {
|
||||
if sum <= 0 {
|
||||
sum = 1
|
||||
}
|
||||
return strconv.FormatFloat(math.Round(weight/sum*1000)/10, 'f', -1, 64) + "%"
|
||||
}
|
||||
|
||||
// formatPoints 把积分写成文本：整数不带小数点，小数最多两位（引擎按份额拆出的 7.5 照实写）。
|
||||
func formatPoints(v float64) string {
|
||||
return strconv.FormatFloat(math.Round(v*100)/100, 'f', -1, 64)
|
||||
}
|
||||
|
||||
// appendNote 把一句说明补进一格文本：原有内容（报名备注、修订痕迹）排在前面，用分号隔开。
|
||||
func appendNote(existing, note string) string {
|
||||
if strings.TrimSpace(note) == "" {
|
||||
return existing
|
||||
}
|
||||
if strings.TrimSpace(existing) == "" {
|
||||
return note
|
||||
}
|
||||
return existing + "；" + note
|
||||
}
|
||||
|
||||
// entrySharesReady 判断份额表在不在。
|
||||
//
|
||||
// 读路径要能读「还没跑到 0024 的库」：没有那张表就没有任何联队配置，显示照旧（主单位独占）。
|
||||
// 与 httpapi.entryTeamSharesReady 同一判据，只是这边没有 context 参数。
|
||||
func entrySharesReady(db *sql.DB) (bool, error) {
|
||||
var n int
|
||||
if err := db.QueryRow(
|
||||
`SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = 'entry_team_shares'`).Scan(&n); err != nil {
|
||||
return false, fmt.Errorf("export: 查询报名份额表: %w", err)
|
||||
}
|
||||
return n != 0, nil
|
||||
}
|
||||
|
||||
// loadJointTeams 读全库的联队配置，按报名 id 归组；只有一条份额的报名不算联队，不进结果。
|
||||
//
|
||||
// 「只有一条」这一档必须排掉：迁移会把每条老报名回填成一条「主单位独占 100%」，
|
||||
// 导入也给普通报名写一条，把它们当成联队会让**所有**导出件的单位名列变成「XX联队」——
|
||||
// 那是老数据逐字节不变这条硬门槛要挡的事。
|
||||
//
|
||||
// 各单位的实得积分一并读出来（分数按份额拆、末位吞余数，只在库里才准），
|
||||
// 用它拼「联队分拆：A 7.5 分、B 7.5 分」。表不在时返回空：没有份额表就没有联队配置。
|
||||
func loadJointTeams(db *sql.DB) (map[int64]jointTeam, error) {
|
||||
ready, err := entrySharesReady(db)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !ready {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
rows, err := db.Query(`
|
||||
SELECT s.entry_id, s.team_id, COALESCE(t.code, ''), COALESCE(t.name, ''), COALESCE(t.short_name, ''),
|
||||
s.points_share, s.medal_share, e.team_id,
|
||||
COALESCE((SELECT SUM(l.points) FROM score_ledger l
|
||||
WHERE l.entry_id = s.entry_id AND l.team_id = s.team_id AND l.voided = 0), 0)
|
||||
FROM entry_team_shares s
|
||||
JOIN teams t ON t.id = s.team_id
|
||||
JOIN entries e ON e.id = s.entry_id
|
||||
ORDER BY s.entry_id, s.sort_order, s.team_id`)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("export: 读取联队份额: %w", err)
|
||||
}
|
||||
defer func() { _ = rows.Close() }()
|
||||
|
||||
grouped := make(map[int64][]jointMember)
|
||||
for rows.Next() {
|
||||
var (
|
||||
entryID int64
|
||||
m jointMember
|
||||
name string
|
||||
short string
|
||||
medal int
|
||||
primary int64
|
||||
)
|
||||
if err := rows.Scan(&entryID, &m.TeamID, &m.Code, &name, &short,
|
||||
&m.Weight, &medal, &primary, &m.Points); err != nil {
|
||||
return nil, fmt.Errorf("export: 扫描联队份额: %w", err)
|
||||
}
|
||||
m.Name = displayName(name, short)
|
||||
if m.Name == "" {
|
||||
m.Name = m.Code
|
||||
}
|
||||
m.CountsMedal = medal != 0
|
||||
m.Primary = primary == m.TeamID
|
||||
grouped[entryID] = append(grouped[entryID], m)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, fmt.Errorf("export: 遍历联队份额: %w", err)
|
||||
}
|
||||
|
||||
out := make(map[int64]jointTeam, len(grouped))
|
||||
for entryID, members := range grouped {
|
||||
if len(members) < 2 {
|
||||
continue
|
||||
}
|
||||
out[entryID] = jointTeam{members: primaryFirst(members)}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// primaryFirst 把主单位挪到成员列表最前面，其余保持份额表的顺序。
|
||||
//
|
||||
// 显示名与导出的 `A+B` 都以主单位打头（口径：加号左边那个是主单位），而份额表里主单位
|
||||
// 不一定排第一——改份额的接口只要求主单位在成员里，没要求它排头。不归位的话，
|
||||
// 一份导出件里的 `B+A` 重导回去会把主单位换成 B，报名身份（唯一键）跟着变。
|
||||
func primaryFirst(members []jointMember) []jointMember {
|
||||
out := make([]jointMember, 0, len(members))
|
||||
for _, m := range members {
|
||||
if m.Primary {
|
||||
out = append(out, m)
|
||||
}
|
||||
}
|
||||
for _, m := range members {
|
||||
if !m.Primary {
|
||||
out = append(out, m)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
@@ -0,0 +1,408 @@
|
||||
package export
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// 联队的导出侧（devdocs/19）：一条成绩按份额拆给多个单位时，导出件必须
|
||||
// 1. 把联队的名字写出来，成员单位名写全（形如「第一分公司+第二分公司联队」）；
|
||||
// 2. 看得出这条分拆给了哪几个单位、各多少（份额 + 各单位实得积分）。
|
||||
// 本文件逐份导出件钉住这两条；另一条硬门槛（没有联队的老数据一字不变）由
|
||||
// TestSingleUnitExportsHaveNoJointTeamText 与既有的各份导出用例共同守住。
|
||||
|
||||
// jointTeamMemberNames 是联队里的两个成员单位（与 seedEvent 的单位一致）。
|
||||
const (
|
||||
jointNameT1 = "第一分公司"
|
||||
jointNameT2 = "第二分公司"
|
||||
// jointTeamDisplay 是联队的显示名：成员单位名写全，中间用 + 连、末尾标「联队」。
|
||||
jointTeamDisplay = jointNameT1 + "+" + jointNameT2 + "联队"
|
||||
// jointShareNote 是均分两份时的份额说明（两条流水的实得积分都是 5 分）。
|
||||
jointShareNote = "联队分拆：第一分公司 5 分（50%）、第二分公司 5 分（50%）"
|
||||
// jointShareOnlyNote 是没有流水时（报名阶段）的份额说明：只讲份额，不讲分。
|
||||
jointShareOnlyNote = "联队分拆：第一分公司 50%、第二分公司 50%"
|
||||
)
|
||||
|
||||
// seedJointTeamEntry 把 seedEvent 的第 1 名改成联队（T1+T2）拿的：份额均分、奖牌整枚各记，
|
||||
// 流水也按份额拆成两行。现场这两样都是引擎算出来的，导出测试直接造库（与 seedChannelRanks 同一套做法）。
|
||||
func seedJointTeamEntry(t *testing.T, db *sql.DB) {
|
||||
t.Helper()
|
||||
|
||||
stmts := []string{
|
||||
`INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order)
|
||||
VALUES (1, 1, 1, 1, 0)`,
|
||||
`INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order)
|
||||
VALUES (1, 2, 1, 1, 1)`,
|
||||
// 引擎把这一条成绩的 10 分拆成两行流水（份额之和归一，两名单位各一半）。
|
||||
`UPDATE score_ledger SET points = 5 WHERE entry_id = 1`,
|
||||
`INSERT INTO score_ledger(team_id, athlete_id, event_id, entry_id, result_id, source_type, source_id, points)
|
||||
VALUES (2, 1, 1, 1, 1, 'result', 1, 5)`,
|
||||
}
|
||||
for _, s := range stmts {
|
||||
if _, err := db.Exec(s); err != nil {
|
||||
t.Fatalf("造联队数据 %q: %v", s, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// seedSingleShareRow 给某条报名只配一条份额：迁移与导入都会这么写（普通报名是「主单位独占 100%」），
|
||||
// 它**不是**联队，导出件必须与升级前一模一样。
|
||||
func seedSingleShareRow(t *testing.T, db *sql.DB, entryID, teamID int64) {
|
||||
t.Helper()
|
||||
if _, err := db.Exec(
|
||||
`INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order)
|
||||
VALUES (?, ?, 1, 1, 0)`, entryID, teamID); err != nil {
|
||||
t.Fatalf("造独占份额: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// 分项成绩表：单位列写全联队成员，备注列写清分给了谁、各多少。
|
||||
func TestJointTeamEventSheetShowsMembersAndShares(t *testing.T) {
|
||||
db := openEventDB(t)
|
||||
seedEvent(t, db)
|
||||
seedJointTeamEntry(t, db)
|
||||
seedChannelRanks(t, db)
|
||||
|
||||
dst := filepath.Join(t.TempDir(), "分项.xlsx")
|
||||
if err := ExportEventXLSX(db, 1, dst, Options{}); err != nil {
|
||||
t.Fatalf("导出分项成绩表: %v", err)
|
||||
}
|
||||
rows := readSheet(t, dst, "田径·100米跑·男子")
|
||||
|
||||
// 第 1 名那条是联队（列序：名次/号码/单位/运动员-队/成绩/积分/状态/备注）。
|
||||
if got := cell(rows, 4, 2); got != jointTeamDisplay {
|
||||
t.Errorf("联队行的单位 = %q，期望 %q", got, jointTeamDisplay)
|
||||
}
|
||||
if got := cell(rows, 4, 5); got != "10" {
|
||||
t.Errorf("联队行的积分 = %q，期望 10（联队拿到的总分）", got)
|
||||
}
|
||||
if got := cell(rows, 4, 7); !strings.Contains(got, jointShareNote) {
|
||||
t.Errorf("联队行的备注 = %q，期望含 %q", got, jointShareNote)
|
||||
}
|
||||
// 第 2 名那条不是联队：单位与备注都不该多出任何东西。
|
||||
if got := cell(rows, 5, 2); got != jointNameT2 {
|
||||
t.Errorf("非联队行的单位 = %q，期望 %q", got, jointNameT2)
|
||||
}
|
||||
if got := cell(rows, 5, 7); got != "" {
|
||||
t.Errorf("非联队行的备注应为空，得到 %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
// 报名名单：单位编码回写成导入时的 A+B 写法（导出件可直接拿去重导），单位名写全联队成员。
|
||||
func TestJointTeamEntriesSheetWritesJointTeamCode(t *testing.T) {
|
||||
db := openEventDB(t)
|
||||
seedEvent(t, db)
|
||||
seedJointTeamEntry(t, db)
|
||||
|
||||
dst := filepath.Join(t.TempDir(), "报名.xlsx")
|
||||
if err := ExportEntriesXLSX(db, dst, EntriesFilter{}, Options{}); err != nil {
|
||||
t.Fatalf("导出报名名单: %v", err)
|
||||
}
|
||||
rows := readSheet(t, dst, "报名名单")
|
||||
|
||||
// 列序：小项编码/小项名/组别/单位编码/单位名/姓名/证件号/号码布/批次/性别/年龄/状态/备注。
|
||||
if got := cell(rows, 4, 3); got != "T1+T2" {
|
||||
t.Errorf("联队行的单位编码 = %q，期望 T1+T2（与导入表的写法一致）", got)
|
||||
}
|
||||
if got := cell(rows, 4, 4); got != jointTeamDisplay {
|
||||
t.Errorf("联队行的单位名 = %q，期望 %q", got, jointTeamDisplay)
|
||||
}
|
||||
if got := cell(rows, 4, 12); !strings.Contains(got, jointShareOnlyNote) {
|
||||
t.Errorf("联队行的备注 = %q，期望含 %q", got, jointShareOnlyNote)
|
||||
}
|
||||
if got := cell(rows, 5, 3); got != "T2" {
|
||||
t.Errorf("非联队行的单位编码 = %q，期望 T2", got)
|
||||
}
|
||||
}
|
||||
|
||||
// 单位积分明细：某单位拿到的这一条来自联队，备注要说清分给了哪几个单位、各多少。
|
||||
func TestJointTeamTeamDetailNotesShare(t *testing.T) {
|
||||
db := openEventDB(t)
|
||||
seedEvent(t, db)
|
||||
seedJointTeamEntry(t, db)
|
||||
|
||||
dst := filepath.Join(t.TempDir(), "单位明细.xlsx")
|
||||
if err := ExportTeamDetailXLSX(db, 1, dst, Options{}); err != nil {
|
||||
t.Fatalf("导出单位积分明细: %v", err)
|
||||
}
|
||||
rows := readSheet(t, dst, "第一分公司积分明细")
|
||||
if got := cell(rows, 4, 8); got != "5" {
|
||||
t.Errorf("联队份额行的积分 = %q，期望 5（本单位那一半）", got)
|
||||
}
|
||||
if got := cell(rows, 4, 9); !strings.Contains(got, jointShareNote) {
|
||||
t.Errorf("联队份额行的备注 = %q，期望含 %q", got, jointShareNote)
|
||||
}
|
||||
|
||||
// 总明细（第一张总表 + 每单位一张分表）与单表同口径，逐格写的是同一句话。
|
||||
allDst := filepath.Join(t.TempDir(), "单位总明细.xlsx")
|
||||
if err := ExportAllTeamDetailsXLSX(db, allDst, Options{}); err != nil {
|
||||
t.Fatalf("导出所有单位积分明细: %v", err)
|
||||
}
|
||||
master := readSheet(t, allDst, "积分总明细")
|
||||
found := false
|
||||
for r := range master {
|
||||
if cell(master, r, 0) == jointNameT1 && strings.Contains(cell(master, r, 10), jointShareNote) {
|
||||
found = true
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
t.Errorf("总明细里第一分公司的联队份额行没有份额说明：%v", master)
|
||||
}
|
||||
}
|
||||
|
||||
// 个人积分总明细：没有备注列，联队说明写在「来源」列（该行得分的来处）。
|
||||
func TestJointTeamAthleteDetailNotesShare(t *testing.T) {
|
||||
db := openEventDB(t)
|
||||
seedEvent(t, db)
|
||||
seedJointTeamEntry(t, db)
|
||||
|
||||
dst := filepath.Join(t.TempDir(), "个人.xlsx")
|
||||
if err := ExportAthleteDetailXLSX(db, dst, Options{}); err != nil {
|
||||
t.Fatalf("导出个人得分明细: %v", err)
|
||||
}
|
||||
rows := readSheet(t, dst, "第一分公司个人得分明细")
|
||||
// 列序：运动员/大项/小项/组别/名次/成绩/得分/来源。
|
||||
if got := cell(rows, 4, 6); got != "5" {
|
||||
t.Errorf("联队份额行的得分 = %q，期望 5", got)
|
||||
}
|
||||
if got := cell(rows, 4, 7); !strings.Contains(got, jointShareNote) {
|
||||
t.Errorf("联队份额行的来源 = %q，期望含 %q", got, jointShareNote)
|
||||
}
|
||||
}
|
||||
|
||||
// 单位奖牌明细：联队金牌两个单位各记一枚，导出件要在那一行就说清「各单位各记 1 枚」，
|
||||
// 否则把各单位的奖牌数加起来会比实际颁发的多（口径 3，不是 bug）。
|
||||
func TestJointTeamMedalDetailShowsEveryUnit(t *testing.T) {
|
||||
db := openEventDB(t)
|
||||
seedEvent(t, db)
|
||||
seedJointTeamEntry(t, db)
|
||||
seedChannelRanks(t, db)
|
||||
|
||||
dst := filepath.Join(t.TempDir(), "奖牌.xlsx")
|
||||
if err := ExportMedalDetailXLSX(db, dst, Options{}); err != nil {
|
||||
t.Fatalf("导出单位奖牌明细: %v", err)
|
||||
}
|
||||
want := "金牌（联队 " + jointNameT1 + "+" + jointNameT2 + "，各单位各记 1 枚）"
|
||||
|
||||
master := readSheet(t, dst, "单位奖牌明细")
|
||||
gold := make([]string, 0, 2)
|
||||
for r := range master {
|
||||
if strings.HasPrefix(cell(master, r, 5), "金牌") {
|
||||
gold = append(gold, cell(master, r, 5))
|
||||
}
|
||||
}
|
||||
if len(gold) != 2 {
|
||||
t.Fatalf("联队金牌应在总表出两行（两个单位各一行），得到 %d 行：%v", len(gold), master)
|
||||
}
|
||||
for i, got := range gold {
|
||||
if got != want {
|
||||
t.Errorf("总表第 %d 行联队奖牌 = %q，期望 %q", i+1, got, want)
|
||||
}
|
||||
}
|
||||
// 非联队的银牌那一行一字不动。
|
||||
plain := false
|
||||
for r := range master {
|
||||
if cell(master, r, 5) == "银牌" {
|
||||
plain = true
|
||||
}
|
||||
}
|
||||
if !plain {
|
||||
t.Errorf("普通奖牌行应保持「银牌」原文：%v", master)
|
||||
}
|
||||
|
||||
// 分表与总表同口径：第一分公司那一张表里的金牌也是同一句话。
|
||||
team := readSheet(t, dst, "第一分公司奖牌明细")
|
||||
if got := cell(team, 4, 4); got != want {
|
||||
t.Errorf("分表联队奖牌 = %q，期望 %q", got, want)
|
||||
}
|
||||
// 分表小计照旧数「本单位拿到几枚」——联队口径下它每个单位各算 1 枚。
|
||||
if got := cell(team, 5, 4); got != "金 1 / 银 0 / 铜 0" {
|
||||
t.Errorf("分表小计 = %q，期望 金 1 / 银 0 / 铜 0", got)
|
||||
}
|
||||
}
|
||||
|
||||
// 含联队的榜单类导出件要有一句口径说明：奖牌按「每个成员单位各记 1 枚」统计，
|
||||
// 各单位奖牌数之和会大于实际颁发数。合计行本身不动（口径 3）。
|
||||
func TestJointTeamStandingsNotesMedalRule(t *testing.T) {
|
||||
db := openEventDB(t)
|
||||
seedEvent(t, db)
|
||||
seedJointTeamEntry(t, db)
|
||||
seedChannelRanks(t, db)
|
||||
|
||||
dst := filepath.Join(t.TempDir(), "总表.xlsx")
|
||||
if err := ExportStandingsXLSX(db, dst, Options{}); err != nil {
|
||||
t.Fatalf("导出总表: %v", err)
|
||||
}
|
||||
medal := readSheet(t, dst, "单位奖牌榜")
|
||||
if got := cell(medal, 1, 0); !strings.Contains(got, "每个成员单位各记 1 枚") {
|
||||
t.Errorf("单位奖牌榜的副标题 = %q，期望含奖牌口径说明", got)
|
||||
}
|
||||
// 口径没变：两个单位各记 1 枚金牌（总表两行都是 1，不是各 0.5）。
|
||||
count := 0
|
||||
for r := range medal {
|
||||
if cell(medal, r, 1) == "T1" || cell(medal, r, 1) == "T2" {
|
||||
if cell(medal, r, 3) != "1" {
|
||||
t.Errorf("%s 金牌 = %q，期望 1（整枚各记）", cell(medal, r, 1), cell(medal, r, 3))
|
||||
}
|
||||
count++
|
||||
}
|
||||
}
|
||||
if count != 2 {
|
||||
t.Errorf("单位奖牌榜应有 2 个单位行，得到 %d", count)
|
||||
}
|
||||
}
|
||||
|
||||
// 球类现场的形态：名次是按单位手工录的（团体通道、没有对应成绩行），channel_ranks 的
|
||||
// entry_id 指到那条联队报名（引擎的 jointTeamEntry 干的活）。奖牌明细同样要认得出联队——
|
||||
// 只按成绩 id 找来源的做法在这里取不到任何展示字段（result_id 为空）。
|
||||
func TestJointTeamMedalDetailFromManualTeamRank(t *testing.T) {
|
||||
db := openEventDB(t)
|
||||
seedEvent(t, db)
|
||||
seedJointTeamEntry(t, db)
|
||||
|
||||
var profileID int64
|
||||
if err := db.QueryRow(`SELECT id FROM scoring_profiles WHERE code = 'team_top6'`).Scan(&profileID); err != nil {
|
||||
t.Fatalf("读团体积分模板: %v", err)
|
||||
}
|
||||
if _, err := db.Exec(`INSERT INTO event_score_channels(event_id, scope, basis, profile_id, sort_order)
|
||||
VALUES (1, 'team', 'manual', ?, 1)`, profileID); err != nil {
|
||||
t.Fatalf("造团体通道: %v", err)
|
||||
}
|
||||
var channelID int64
|
||||
if err := db.QueryRow(`SELECT id FROM event_score_channels
|
||||
WHERE event_id = 1 AND scope = 'team' AND basis = 'manual'`).Scan(&channelID); err != nil {
|
||||
t.Fatalf("读团体通道: %v", err)
|
||||
}
|
||||
if _, err := db.Exec(`INSERT INTO channel_ranks(event_id, category_id, channel_id, basis, scope, subject_key,
|
||||
entry_id, result_id, team_id, rank, points, status)
|
||||
VALUES (1, 1, ?, 'manual', 'team', 'e:1', 1, NULL, 1, 1, 0, 'ok')`, channelID); err != nil {
|
||||
t.Fatalf("造团体手工名次: %v", err)
|
||||
}
|
||||
|
||||
dst := filepath.Join(t.TempDir(), "奖牌.xlsx")
|
||||
if err := ExportMedalDetailXLSX(db, dst, Options{}); err != nil {
|
||||
t.Fatalf("导出单位奖牌明细: %v", err)
|
||||
}
|
||||
want := "金牌（联队 " + jointNameT1 + "+" + jointNameT2 + "，各单位各记 1 枚）"
|
||||
master := readSheet(t, dst, "单位奖牌明细")
|
||||
gold := 0
|
||||
for r := range master {
|
||||
if strings.HasPrefix(cell(master, r, 5), "金牌") {
|
||||
gold++
|
||||
if got := cell(master, r, 5); got != want {
|
||||
t.Errorf("总表联队奖牌 = %q，期望 %q", got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
if gold != 2 {
|
||||
t.Fatalf("联队金牌应给两个单位各出一行，得到 %d 行：%v", gold, master)
|
||||
}
|
||||
}
|
||||
|
||||
// 按成员单位筛报名名单：联队那条报名挂在主单位（T1）名下，但成员单位 T2 的名单里也得有它，
|
||||
// 否则 T2 导出自己的名单时，会以为自己没派人上场。
|
||||
func TestJointTeamEntriesSheetFilteredByMemberUnit(t *testing.T) {
|
||||
db := openEventDB(t)
|
||||
seedEvent(t, db)
|
||||
seedJointTeamEntry(t, db)
|
||||
|
||||
dst := filepath.Join(t.TempDir(), "报名.xlsx")
|
||||
if err := ExportEntriesXLSX(db, dst, EntriesFilter{TeamID: 2}, Options{}); err != nil {
|
||||
t.Fatalf("按成员单位导出报名名单: %v", err)
|
||||
}
|
||||
rows := readSheet(t, dst, "报名名单")
|
||||
found := false
|
||||
for r := range rows {
|
||||
if cell(rows, r, 3) == "T1+T2" {
|
||||
found = true
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
t.Errorf("按成员单位 T2 导出时应能看到联队那条报名：%v", rows)
|
||||
}
|
||||
// 主单位筛选照旧（老行为一字不改）。
|
||||
primaryDst := filepath.Join(t.TempDir(), "报名主单位.xlsx")
|
||||
if err := ExportEntriesXLSX(db, primaryDst, EntriesFilter{TeamID: 1}, Options{}); err != nil {
|
||||
t.Fatalf("按主单位导出报名名单: %v", err)
|
||||
}
|
||||
primary := readSheet(t, primaryDst, "报名名单")
|
||||
if len(primary) != 5 { // 4 行版式 + 主单位自己的那一条
|
||||
t.Fatalf("按主单位筛应只出 T1 的那一条，得到 %d 行：%v", len(primary), primary)
|
||||
}
|
||||
}
|
||||
|
||||
// 份额表里主单位不排第一时（改份额的接口允许这样写），导出件的名字与 A+B 仍以主单位打头：
|
||||
// 否则 `B+A` 重导回去会把报名的主单位换成 B。
|
||||
func TestJointTeamDisplayPutsPrimaryFirst(t *testing.T) {
|
||||
db := openEventDB(t)
|
||||
seedEvent(t, db)
|
||||
// 故意把成员单位排在主单位前面（sort_order 0 = T2，1 = T1）。
|
||||
for _, s := range []string{
|
||||
`INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order) VALUES (1, 2, 1, 1, 0)`,
|
||||
`INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order) VALUES (1, 1, 1, 1, 1)`,
|
||||
} {
|
||||
if _, err := db.Exec(s); err != nil {
|
||||
t.Fatalf("造份额 %q: %v", s, err)
|
||||
}
|
||||
}
|
||||
|
||||
dst := filepath.Join(t.TempDir(), "报名.xlsx")
|
||||
if err := ExportEntriesXLSX(db, dst, EntriesFilter{}, Options{}); err != nil {
|
||||
t.Fatalf("导出报名名单: %v", err)
|
||||
}
|
||||
rows := readSheet(t, dst, "报名名单")
|
||||
if got := cell(rows, 4, 3); got != "T1+T2" {
|
||||
t.Errorf("单位编码 = %q，期望 T1+T2（主单位永远排最前）", got)
|
||||
}
|
||||
if got := cell(rows, 4, 4); got != jointTeamDisplay {
|
||||
t.Errorf("单位名 = %q，期望 %q", got, jointTeamDisplay)
|
||||
}
|
||||
}
|
||||
|
||||
// 老数据门槛：只有一条独占份额（普通报名 / 迁移回填）时，各份导出件一个字都不能多。
|
||||
func TestSingleUnitExportsHaveNoJointTeamText(t *testing.T) {
|
||||
db := openEventDB(t)
|
||||
seedEvent(t, db)
|
||||
// 迁移与导入都会给每条报名写一条独占份额：它不是联队。
|
||||
seedSingleShareRow(t, db, 1, 1)
|
||||
seedSingleShareRow(t, db, 2, 2)
|
||||
seedChannelRanks(t, db)
|
||||
|
||||
dir := t.TempDir()
|
||||
eventDst := filepath.Join(dir, "分项.xlsx")
|
||||
if err := ExportEventXLSX(db, 1, eventDst, Options{}); err != nil {
|
||||
t.Fatalf("导出分项成绩表: %v", err)
|
||||
}
|
||||
rows := readSheet(t, eventDst, "田径·100米跑·男子")
|
||||
if got := cell(rows, 4, 2); got != jointNameT1 {
|
||||
t.Errorf("普通报名的单位 = %q，期望 %q（联队显示名不能套到独占份额上）", got, jointNameT1)
|
||||
}
|
||||
if got := cell(rows, 4, 7); got != "" {
|
||||
t.Errorf("普通报名的备注应为空，得到 %q", got)
|
||||
}
|
||||
|
||||
entriesDst := filepath.Join(dir, "报名.xlsx")
|
||||
if err := ExportEntriesXLSX(db, entriesDst, EntriesFilter{}, Options{}); err != nil {
|
||||
t.Fatalf("导出报名名单: %v", err)
|
||||
}
|
||||
erows := readSheet(t, entriesDst, "报名名单")
|
||||
if got := cell(erows, 4, 3); got != "T1" {
|
||||
t.Errorf("普通报名的单位编码 = %q，期望 T1", got)
|
||||
}
|
||||
if got := cell(erows, 4, 4); got != jointNameT1 {
|
||||
t.Errorf("普通报名的单位名 = %q，期望 %q", got, jointNameT1)
|
||||
}
|
||||
|
||||
standingsDst := filepath.Join(dir, "总表.xlsx")
|
||||
if err := ExportStandingsXLSX(db, standingsDst, Options{}); err != nil {
|
||||
t.Fatalf("导出总表: %v", err)
|
||||
}
|
||||
medal := readSheet(t, standingsDst, "单位奖牌榜")
|
||||
for r := range medal {
|
||||
if strings.Contains(cell(medal, r, 0), "联队") || strings.Contains(cell(medal, r, 1), "联队") {
|
||||
t.Errorf("无联队时副标题不该出现联队口径说明：%v", medal[r])
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
package export
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
// 导出是联队奖牌的第三条读路径（另有 REST 与 WS 快照）：它同样读 channel_ranks，
|
||||
// 再按报名项的份额补归属。少了这一步，导出的单位奖牌榜会把联队的金牌只记给主单位。
|
||||
func TestJointTeamMedalExportCountsEveryMember(t *testing.T) {
|
||||
db := openEventDB(t)
|
||||
seedEvent(t, db) // T1 第 1 名、T2 第 2 名
|
||||
// 把 T1 的第 1 名改成联队（T1 + T2）拿的：份额均分、奖牌整枚各记。
|
||||
for _, s := range []string{
|
||||
`INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order) VALUES (1, 1, 1, 1, 0)`,
|
||||
`INSERT INTO entry_team_shares(entry_id, team_id, points_share, medal_share, sort_order) VALUES (1, 2, 1, 1, 1)`,
|
||||
} {
|
||||
if _, err := db.Exec(s); err != nil {
|
||||
t.Fatalf("造联队份额 %q: %v", s, err)
|
||||
}
|
||||
}
|
||||
seedChannelRanks(t, db)
|
||||
|
||||
book, err := LoadStandingsWorkbook(db, Options{})
|
||||
if err != nil {
|
||||
t.Fatalf("读榜单工作簿: %v", err)
|
||||
}
|
||||
gold := make(map[int64]int, len(book.Medal))
|
||||
for _, row := range book.Medal {
|
||||
gold[row.TeamID] = row.Gold
|
||||
}
|
||||
if gold[1] != 1 {
|
||||
t.Fatalf("主单位 T1 应记 1 枚金牌，得到 %d（完整：%+v）", gold[1], book.Medal)
|
||||
}
|
||||
if gold[2] != 1 {
|
||||
t.Fatalf("成员单位 T2 也应记 1 枚金牌（不是 0.5 枚、也不是 0 枚），得到 %d（完整：%+v）", gold[2], book.Medal)
|
||||
}
|
||||
}
|
||||
@@ -23,6 +23,10 @@ type Meta struct {
|
||||
// 所以这一行事实上不会出现在导出件里；空值时 metaSubtitle 直接跳过它（代码卫生项 C28）。
|
||||
// 留字段是因为打印件抬头本来就该有「谁导的」——要接线时由 handler 从会话里取用户名填进来即可。
|
||||
GeneratedBy string
|
||||
// Note 是附在副标题后面的口径说明，由 Load* 按数据内容补（当前只有「本赛事含联队」时才会写：
|
||||
// 奖牌每个成员单位各记 1 枚，各单位奖牌数之和会大于实际颁发数）。
|
||||
// 留空时副标题与改动前逐字一致——无联队的老导出件不能因为加了这个字段而变形。
|
||||
Note string
|
||||
}
|
||||
|
||||
func (m Meta) normalized() Meta {
|
||||
@@ -132,6 +136,15 @@ func LoadStandingsWorkbook(db *sql.DB, opts Options) (StandingsWorkbook, error)
|
||||
medal := domain.BuildMedalStandings(in)
|
||||
athlete := domain.BuildAthleteStandings(in)
|
||||
fillTeamDisplay(team, medal, athlete, allTeams)
|
||||
// 含联队时在副标题上写清奖牌口径：每个成员单位各记 1 枚，各单位奖牌数之和会大于实际颁发数。
|
||||
// 合计行本身不改（那是定稿口径），只把那个数字解释清楚。
|
||||
joints, err := loadJointTeams(db)
|
||||
if err != nil {
|
||||
return StandingsWorkbook{}, err
|
||||
}
|
||||
if len(joints) > 0 {
|
||||
meta.Note = jointMedalNote
|
||||
}
|
||||
return StandingsWorkbook{Meta: meta, Team: team, Medal: medal, Athlete: athlete}, nil
|
||||
}
|
||||
|
||||
@@ -330,11 +343,6 @@ func loadRanked(db *sql.DB) ([]domain.RankedResult, error) {
|
||||
v := value.Float64
|
||||
rr.ResultValue = &v
|
||||
}
|
||||
// 归属份额沿用「主单位独占 100%」：team_id 为空（聚合 / 团体手工名次理论上不会）时不造份额，
|
||||
// 免得给 0 号单位凭空记牌，与 domain 的 wholeShare 一致。
|
||||
if rr.TeamID != 0 {
|
||||
rr.Shares = []domain.TeamShare{{TeamID: rr.TeamID, Weight: 1}}
|
||||
}
|
||||
rr.AwardMedals = awardMedals != 0
|
||||
rr.CountToMedals = countToMedals != 0
|
||||
rr.CountToTeamMedals = countToTeamMed != 0
|
||||
@@ -343,9 +351,60 @@ func loadRanked(db *sql.DB) ([]domain.RankedResult, error) {
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, fmt.Errorf("export: 遍历名次: %w", err)
|
||||
}
|
||||
// 归属份额按报名项配置补（联队：一条成绩归多个单位）：与 REST 的 buildRanked、
|
||||
// 快照的 loadRanked 同口径。没有报名项的名次与没配份额的老数据都退回「主单位独占 100%」，
|
||||
// team_id 为空时不造份额，免得给 0 号单位凭空记牌。
|
||||
shares, err := loadEntryTeamShares(db)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for i := range out {
|
||||
out[i].Shares = domain.ResolveShares(shares[out[i].EntryID], out[i].TeamID)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// loadEntryTeamShares 读全部报名的份额（联队配置），按 entry_id 归组。
|
||||
// 与 HTTP 侧的 loadEntryTeamSharesQ 同一份表、同一套排序：展示与流水顺序要稳定。
|
||||
//
|
||||
// 表不在（库还没跑到 0024）时返回空：没有份额表就没有联队配置，主单位独占 100% 正是老库
|
||||
// 本来就该得到的结果，不是容错降级（见 httpapi.entryTeamSharesReady）。
|
||||
func loadEntryTeamShares(db *sql.DB) (map[int64][]domain.TeamShare, error) {
|
||||
var n int
|
||||
if err := db.QueryRow(
|
||||
`SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = 'entry_team_shares'`).Scan(&n); err != nil {
|
||||
return nil, fmt.Errorf("export: 查询报名份额表: %w", err)
|
||||
}
|
||||
if n == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
rows, err := db.Query(`SELECT entry_id, team_id, points_share, medal_share
|
||||
FROM entry_team_shares
|
||||
ORDER BY entry_id, sort_order, team_id`)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("export: 读取报名份额: %w", err)
|
||||
}
|
||||
defer func() { _ = rows.Close() }()
|
||||
|
||||
out := make(map[int64][]domain.TeamShare)
|
||||
for rows.Next() {
|
||||
var (
|
||||
entryID int64
|
||||
s domain.TeamShare
|
||||
medal int
|
||||
)
|
||||
if err := rows.Scan(&entryID, &s.TeamID, &s.Weight, &medal); err != nil {
|
||||
return nil, fmt.Errorf("export: 扫描报名份额: %w", err)
|
||||
}
|
||||
if medal == 0 {
|
||||
excluded := false
|
||||
s.Medal = &excluded
|
||||
}
|
||||
out[entryID] = append(out[entryID], s)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// eventInfo 是导出分项成绩表需要的项目信息。
|
||||
type eventInfo struct {
|
||||
id int64
|
||||
@@ -372,13 +431,18 @@ func LoadEventWorkbook(db *sql.DB, eventID int64, opts Options) (EventsWorkbook,
|
||||
}
|
||||
|
||||
sheets := make([]EventSheet, 0, len(events))
|
||||
// 联队配置读一次给全部工作表复用：一个小项组别一张表，逐张去查会白跑几十遍。
|
||||
joints, err := loadJointTeams(db)
|
||||
if err != nil {
|
||||
return EventsWorkbook{}, err
|
||||
}
|
||||
for _, ev := range events {
|
||||
cats, err := loadCategories(db, ev.id)
|
||||
if err != nil {
|
||||
return EventsWorkbook{}, err
|
||||
}
|
||||
if len(cats) == 0 {
|
||||
rows, err := loadEventRows(db, ev.id, 0, opts.IncludeDrafts)
|
||||
rows, err := loadEventRows(db, ev.id, 0, opts.IncludeDrafts, joints)
|
||||
if err != nil {
|
||||
return EventsWorkbook{}, err
|
||||
}
|
||||
@@ -386,7 +450,7 @@ func LoadEventWorkbook(db *sql.DB, eventID int64, opts Options) (EventsWorkbook,
|
||||
continue
|
||||
}
|
||||
for _, cat := range cats {
|
||||
rows, err := loadEventRows(db, ev.id, cat.id, opts.IncludeDrafts)
|
||||
rows, err := loadEventRows(db, ev.id, cat.id, opts.IncludeDrafts, joints)
|
||||
if err != nil {
|
||||
return EventsWorkbook{}, err
|
||||
}
|
||||
@@ -465,7 +529,7 @@ func loadCategories(db *sql.DB, eventID int64) ([]categoryInfo, error) {
|
||||
// 未录入成绩的报名项也会列出，状态显示「未录入」——现场核对名单时用得上。
|
||||
// includeDrafts 为 false 时草稿成绩的值不对外，但那一行仍占位（Unpublished）；
|
||||
// 连成绩行都没有的报名项同样占位（NoResult）；成绩已发布但整组还没结算的占位（Unsettled）。
|
||||
func loadEventRows(db *sql.DB, eventID, categoryID int64, includeDrafts bool) ([]EventResultRow, error) {
|
||||
func loadEventRows(db *sql.DB, eventID, categoryID int64, includeDrafts bool, joints map[int64]jointTeam) ([]EventResultRow, error) {
|
||||
// 名次列取「主通道」名次（devdocs 17 §11.3）：双通道项目（个人通道 + 团体通道）一行只能出一个名次，
|
||||
// 口径 = scope=athlete 优先，其次通道 sort_order 小者。
|
||||
// channel_ranks 是发布 / 重算才重建的派生数据，还没有它时（老库刚升级、只排名不计分项目的合成通道
|
||||
@@ -484,7 +548,7 @@ func loadEventRows(db *sql.DB, eventID, categoryID int64, includeDrafts bool) ([
|
||||
WHERE l.entry_id = en.id AND l.voided = 0), 0),
|
||||
r.status, r.state, en.status, COALESCE(en.remark, ''), COALESCE(r.note, ''),
|
||||
r.result_value IS NOT NULL,
|
||||
COALESCE(gs.required, 0), COALESCE(gs.published, 0)
|
||||
COALESCE(gs.required, 0), COALESCE(gs.published, 0), en.id
|
||||
FROM entries en
|
||||
JOIN teams t ON t.id = en.team_id
|
||||
LEFT JOIN athletes a ON a.id = en.athlete_id
|
||||
@@ -535,16 +599,23 @@ func loadEventRows(db *sql.DB, eventID, categoryID int64, includeDrafts bool) ([
|
||||
resultNote string
|
||||
hasValue int
|
||||
required, published int
|
||||
entryID int64
|
||||
)
|
||||
if err := rows.Scan(&rank, &isTie, &row.Bib, &memberJSON, &row.TeamName, &athleteName,
|
||||
&row.ResultText, &row.Unit, &row.Points, &resultStat, &resultState, &entryStat,
|
||||
&entryRemark, &resultNote, &hasValue, &required, &published); err != nil {
|
||||
&entryRemark, &resultNote, &hasValue, &required, &published, &entryID); err != nil {
|
||||
return nil, fmt.Errorf("export: 扫描成绩: %w", err)
|
||||
}
|
||||
row.Participant = participantName(athleteName, memberJSON)
|
||||
row.Rank = rankLabel(rank, isTie != 0)
|
||||
row.Status = statusLabel(resultStat, resultState, entryStat)
|
||||
row.Remark = joinRemark(entryRemark, resultNote)
|
||||
// 联队：单位列写全成员单位（「第一分公司+第二分公司联队」），备注里写清分给了谁、各多少。
|
||||
// 普通报名（含迁移回填的单条独占份额）不走这里，单位名与备注与改动前逐字一致。
|
||||
if joint, ok := joints[entryID]; ok {
|
||||
row.TeamName = joint.Name()
|
||||
row.Remark = appendNote(row.Remark, joint.shareNote())
|
||||
}
|
||||
// results.state 是 NOT NULL，所以 state 为空只可能是 LEFT JOIN 没命中所致：这条报名还没录成绩。
|
||||
// 它与「有草稿没发布」要分开：前者三格都没值，后者只是成绩值不对外。
|
||||
row.NoResult = !resultState.Valid
|
||||
@@ -585,7 +656,11 @@ func LoadTeamDetailWorkbook(db *sql.DB, teamID int64, opts Options) (TeamDetailW
|
||||
if err != nil {
|
||||
return TeamDetailWorkbook{}, err
|
||||
}
|
||||
rows, err := loadTeamDetailRows(db, teamID)
|
||||
joints, err := loadJointTeams(db)
|
||||
if err != nil {
|
||||
return TeamDetailWorkbook{}, err
|
||||
}
|
||||
rows, err := loadTeamDetailRows(db, teamID, joints)
|
||||
if err != nil {
|
||||
return TeamDetailWorkbook{}, err
|
||||
}
|
||||
@@ -638,7 +713,7 @@ const teamDetailRankExpr = `COALESCE((
|
||||
ORDER BY CASE WHEN ch.scope = 'athlete' THEN 0 ELSE 1 END, ch.sort_order, ch.id, cr.id
|
||||
LIMIT 1), COALESCE(r.rank, 0))`
|
||||
|
||||
func loadTeamDetailRows(db *sql.DB, teamID int64) ([]TeamDetailRow, error) {
|
||||
func loadTeamDetailRows(db *sql.DB, teamID int64, joints map[int64]jointTeam) ([]TeamDetailRow, error) {
|
||||
// 聚合通道（basis=aggregate，即「按队内平均」）的流水 entry_id / result_id 都为空，
|
||||
// 从 entries 取不到组别。这类流水是「单位在本组别的成绩取平均」的产物，组别在算分时已经确定；
|
||||
// 库里没把它落到流水上，只能回推：单位在本小项只参加了一个组别时，那个组别就是答案（ac 子查询）。
|
||||
@@ -691,6 +766,11 @@ func loadTeamDetailRows(db *sql.DB, teamID int64) ([]TeamDetailRow, error) {
|
||||
// 在一份表里是「11.58 秒」、在另一份里是「11.58」，两张表摆在一起核对时会被当成两个数。
|
||||
r.ResultText = displayResult(resultText, unit)
|
||||
r.Source = sourceLabel(source)
|
||||
// 这条流水来自联队时说明份额：本单位拿到的是拆给它的那一份（积分列已经是拆后的值），
|
||||
// 备注里再把「分给了哪几个单位、各多少」一次写全，核对时不必回头查另一张表。
|
||||
if joint, ok := joints[entryID]; ok {
|
||||
r.Remark = appendNote(r.Remark, joint.shareNote())
|
||||
}
|
||||
r.individual = athleteID != 0
|
||||
keys = append(keys, revisions.KeyFor(source, eventID, entryID))
|
||||
out = append(out, r)
|
||||
|
||||
@@ -32,6 +32,10 @@ type MedalDetailRow struct {
|
||||
Medal string
|
||||
Participant string
|
||||
|
||||
// jointNote 是联队奖牌的展示值（非空时覆盖 Medal 列）：「金牌（联队 A+B，各单位各记 1 枚）」。
|
||||
// 口径是每个成员单位各记一整枚，各单位的奖牌数加起来会比实际颁发的多，这一格就是那句解释。
|
||||
jointNote string
|
||||
|
||||
// 排序键，只在本包内用，不导出。
|
||||
sportSort int
|
||||
eventSort int
|
||||
@@ -59,7 +63,9 @@ var medalDetailColumns = []column{
|
||||
{"小项", 18, kindText},
|
||||
{"组别", 14, kindText},
|
||||
{"名次", 8, kindCenter},
|
||||
{"奖牌", 8, kindCenter},
|
||||
// 奖牌列不是窄的居中列：联队奖牌要把「各单位各记 1 枚」写在奖牌格子里（口径 3），
|
||||
// 窄列 + 居中 + 不换行会被右边非空的「运动员/队」裁掉，那句话就白写了。
|
||||
{"奖牌", 26, kindText},
|
||||
// 与分项成绩表的「运动员/队」同宽：奖牌明细同样会印接力队名单。
|
||||
{"运动员/队", 24, kindText},
|
||||
}
|
||||
@@ -153,7 +159,11 @@ func medalRow(r MedalDetailRow) []any {
|
||||
if r.Rank > 0 {
|
||||
rank = strconv.Itoa(r.Rank)
|
||||
}
|
||||
return []any{r.SportName, r.EventName, r.Category, rank, r.Medal, r.Participant}
|
||||
medal := any(r.Medal)
|
||||
if r.jointNote != "" {
|
||||
medal = r.jointNote
|
||||
}
|
||||
return []any{r.SportName, r.EventName, r.Category, rank, medal, r.Participant}
|
||||
}
|
||||
|
||||
// LoadMedalDetailWorkbook 读取全部奖牌来源。
|
||||
@@ -168,6 +178,14 @@ func LoadMedalDetailWorkbook(db *sql.DB, opts Options) (MedalDetailWorkbook, err
|
||||
if err != nil {
|
||||
return MedalDetailWorkbook{}, err
|
||||
}
|
||||
// 联队配置：一条成绩归多个单位时，每个成员单位各记一枚整牌，奖牌那一格要写清这件事。
|
||||
joints, err := loadJointTeams(db)
|
||||
if err != nil {
|
||||
return MedalDetailWorkbook{}, err
|
||||
}
|
||||
if len(joints) > 0 {
|
||||
meta.Note = jointMedalNote
|
||||
}
|
||||
// 名次输入与榜单同源：loadRanked 只取已发布、有效、计分小项的名次。
|
||||
ranked, err := loadRanked(db)
|
||||
if err != nil {
|
||||
@@ -197,7 +215,7 @@ func LoadMedalDetailWorkbook(db *sql.DB, opts Options) (MedalDetailWorkbook, err
|
||||
|
||||
sheets := make([]MedalDetailSheet, 0, len(teams))
|
||||
for _, t := range teams {
|
||||
rows := medalRowsOfTeam(t.ID, hits, ctx, eventCtx)
|
||||
rows := medalRowsOfTeam(t.ID, hits, ctx, eventCtx, joints)
|
||||
if len(rows) == 0 {
|
||||
continue
|
||||
}
|
||||
@@ -208,10 +226,13 @@ func LoadMedalDetailWorkbook(db *sql.DB, opts Options) (MedalDetailWorkbook, err
|
||||
|
||||
// medalHit 是一枚奖牌：来自哪个小项 / 组别的哪条成绩、什么名次、什么牌。
|
||||
// 聚合名次与团体手工名次没有单条成绩（resultID 为 0），小项 + 组别是展示字段的兜底来源。
|
||||
// entryID 是这条名次对应的报名项：联队份额挂在报名的，联队奖牌的那句说明只能靠它查到
|
||||
// （球类现场的名次正是手工按单位录的，此时 resultID 为空，只有 entryID 认得出来）。
|
||||
type medalHit struct {
|
||||
eventID int64
|
||||
categoryID int64
|
||||
resultID int64
|
||||
entryID int64
|
||||
rank int
|
||||
medal string
|
||||
}
|
||||
@@ -235,15 +256,18 @@ func medalHits(ranked []domain.RankedResult, excludeTeam bool) map[int64][]medal
|
||||
for _, row := range rows {
|
||||
for i := 0; i < row.Gold; i++ {
|
||||
out[row.TeamID] = append(out[row.TeamID], medalHit{
|
||||
eventID: rr.EventID, categoryID: rr.CategoryID, resultID: rr.ResultID, rank: 1, medal: medalGold})
|
||||
eventID: rr.EventID, categoryID: rr.CategoryID, resultID: rr.ResultID,
|
||||
entryID: rr.EntryID, rank: 1, medal: medalGold})
|
||||
}
|
||||
for i := 0; i < row.Silver; i++ {
|
||||
out[row.TeamID] = append(out[row.TeamID], medalHit{
|
||||
eventID: rr.EventID, categoryID: rr.CategoryID, resultID: rr.ResultID, rank: 2, medal: medalSilver})
|
||||
eventID: rr.EventID, categoryID: rr.CategoryID, resultID: rr.ResultID,
|
||||
entryID: rr.EntryID, rank: 2, medal: medalSilver})
|
||||
}
|
||||
for i := 0; i < row.Bronze; i++ {
|
||||
out[row.TeamID] = append(out[row.TeamID], medalHit{
|
||||
eventID: rr.EventID, categoryID: rr.CategoryID, resultID: rr.ResultID, rank: 3, medal: medalBronze})
|
||||
eventID: rr.EventID, categoryID: rr.CategoryID, resultID: rr.ResultID,
|
||||
entryID: rr.EntryID, rank: 3, medal: medalBronze})
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -385,7 +409,7 @@ func loadMedalEventContext(db *sql.DB) (map[eventCategoryKey]medalContext, error
|
||||
|
||||
// medalRowsOfTeam 把某单位的奖牌拼成展示行，按大项/小项/组别/名次的既有顺序排列。
|
||||
// 展示字段优先按成绩取（能带上运动员 / 接力队名单），取不到再按小项 + 组别兜底。
|
||||
func medalRowsOfTeam(teamID int64, hits map[int64][]medalHit, ctx map[int64]medalContext, eventCtx map[eventCategoryKey]medalContext) []MedalDetailRow {
|
||||
func medalRowsOfTeam(teamID int64, hits map[int64][]medalHit, ctx map[int64]medalContext, eventCtx map[eventCategoryKey]medalContext, joints map[int64]jointTeam) []MedalDetailRow {
|
||||
list := hits[teamID]
|
||||
rows := make([]MedalDetailRow, 0, len(list))
|
||||
for _, h := range list {
|
||||
@@ -393,7 +417,7 @@ func medalRowsOfTeam(teamID int64, hits map[int64][]medalHit, ctx map[int64]meda
|
||||
if !ok {
|
||||
c = eventCtx[eventCategoryKey{eventID: h.eventID, categoryID: h.categoryID}]
|
||||
}
|
||||
rows = append(rows, MedalDetailRow{
|
||||
row := MedalDetailRow{
|
||||
SportName: c.sportName,
|
||||
EventName: c.eventName,
|
||||
Category: c.category,
|
||||
@@ -406,7 +430,15 @@ func medalRowsOfTeam(teamID int64, hits map[int64][]medalHit, ctx map[int64]meda
|
||||
eventID: c.eventID,
|
||||
categoryID: c.categoryID,
|
||||
resultID: h.resultID,
|
||||
})
|
||||
}
|
||||
// 联队奖牌：把成员单位与「各单位各记 1 枚」写在奖牌那一格（口径 3）。
|
||||
// 名次不带报名项时（聚合通道）不补：那种名次本来就不拆份额，说明只会误导。
|
||||
if h.entryID != 0 {
|
||||
if joint, ok := joints[h.entryID]; ok {
|
||||
row.jointNote = joint.medalCell(h.medal)
|
||||
}
|
||||
}
|
||||
rows = append(rows, row)
|
||||
}
|
||||
sort.SliceStable(rows, func(i, j int) bool {
|
||||
a, b := rows[i], rows[j]
|
||||
|
||||
@@ -343,6 +343,9 @@ func metaSubtitle(m Meta) string {
|
||||
if m.GeneratedBy != "" {
|
||||
parts = append(parts, "导出人 "+m.GeneratedBy)
|
||||
}
|
||||
if m.Note != "" {
|
||||
parts = append(parts, m.Note)
|
||||
}
|
||||
return strings.Join(parts, " · ")
|
||||
}
|
||||
|
||||
|
||||
@@ -126,9 +126,15 @@ func LoadAllTeamDetailsWorkbook(db *sql.DB, opts Options) (AllTeamDetailsWorkboo
|
||||
}
|
||||
orderTeamsByStandings(teams, order)
|
||||
|
||||
// 联队配置读一次给全部单位分表复用（几个单位就查几遍纯属浪费）。
|
||||
joints, err := loadJointTeams(db)
|
||||
if err != nil {
|
||||
return AllTeamDetailsWorkbook{}, err
|
||||
}
|
||||
|
||||
sheets := make([]TeamDetailSheet, 0, len(teams))
|
||||
for _, t := range teams {
|
||||
rows, err := loadTeamDetailRows(db, t.ID)
|
||||
rows, err := loadTeamDetailRows(db, t.ID, joints)
|
||||
if err != nil {
|
||||
return AllTeamDetailsWorkbook{}, err
|
||||
}
|
||||
|
||||
@@ -129,6 +129,24 @@ type entryDTO struct {
|
||||
TeamName string `json:"teamName,omitempty"`
|
||||
ShortName *string `json:"shortName,omitempty"`
|
||||
CategoryName string `json:"categoryName,omitempty"`
|
||||
// TeamShares 是这条报名的归属份额（联队）：读侧至少一条，第一条是主单位（= teamId）。
|
||||
// 普通报名也下发一条独占份额，前端不必为「有没有联队」写两套渲染。
|
||||
TeamShares []entryTeamShareDTO `json:"teamShares"`
|
||||
}
|
||||
|
||||
// entryTeamShareDTO 是报名份额的一条（联队的一个成员单位）。
|
||||
//
|
||||
// - weight：积分份额，**相对权重**（缺省 1）。引擎按权重之和归一，所以 1+1 与 0.5+0.5 等价；
|
||||
// 入库也就存原值，不做归一，避免 2:1 被写成 0.666…/0.333… 这种除不尽的数。
|
||||
// - medal ：这枚奖牌是否**整枚**记给该单位（缺省 true）。联队的金牌两个单位各记 1 枚，
|
||||
// 与 weight 无关——奖牌榜数整数枚，不按积分权重拆。
|
||||
// - teamCode / teamName 是读侧补的展示字段（前端拼「A+B联队」用），写侧不需要带。
|
||||
type entryTeamShareDTO struct {
|
||||
TeamID int64 `json:"teamId"`
|
||||
Weight float64 `json:"weight"`
|
||||
Medal *bool `json:"medal,omitempty"`
|
||||
TeamCode string `json:"teamCode,omitempty"`
|
||||
TeamName string `json:"teamName,omitempty"`
|
||||
}
|
||||
|
||||
type entryWithResultDTO struct {
|
||||
|
||||
@@ -433,6 +433,56 @@ func entryTemplateHeader(language string) []string {
|
||||
return out
|
||||
}
|
||||
|
||||
// 联队（devdocs/19）怎么写，是模板必须教给填表人的事：单位编码写 `A+B`，加号左边是主单位，
|
||||
// 积分平均分、奖牌两边各记一枚。中英各一份，与表头语言一致。
|
||||
//
|
||||
// 文案只能挂在**不会变成数据的载体**上：表头行是导入器认模板的锚点（必须留在第 1 行、12 列
|
||||
// 一字不动），工作表名是「小项@组别」的范围锚点（也不能多出一张说明表，否则整份文件按分工作表
|
||||
// 口径解析时会对不上号）。所以这里用两处：单位编码表头的**单元格批注**（红三角一眼能看见）
|
||||
// 与这一列的**输入提示**（点中格子就弹出来）。
|
||||
const (
|
||||
entryJointHintZH = "单位编码怎么写：\n" +
|
||||
"· 单个单位参赛：填它的编码，例如 A。\n" +
|
||||
"· 同一小项组别里两个单位联合参赛（联队）：写 A+B，加号左边那个是主单位。\n" +
|
||||
" 积分在两个单位之间平均分（各 50%，拆出 0.5 分照实记）；\n" +
|
||||
" 奖牌两边各记一枚整牌——联队的金牌，A、B 各记 1 枚。"
|
||||
entryJointPromptZH = "联队写 A+B（加号左边是主单位）：积分平均分，奖牌两边各记一枚"
|
||||
entryJointTitleZH = "单位编码怎么写"
|
||||
entryJointHintEN = "How to fill the team code:\n" +
|
||||
"- One unit: its code, for example A.\n" +
|
||||
"- Two units entering together as a joint team (same event and category): write A+B, " +
|
||||
"the left one is the primary unit.\n" +
|
||||
" Points are split evenly between them (50% each; halves such as 7.5 are kept as they are);\n" +
|
||||
" each unit is credited one full medal - a joint gold counts as one for A and one for B."
|
||||
entryJointPromptEN = "Joint team: write A+B (left one is the primary unit). " +
|
||||
"Points split evenly, each unit gets one full medal"
|
||||
entryJointTitleEN = "How to fill the team code"
|
||||
// entryTemplateAuthor 是批注作者。写系统名（与导出件的文档属性同一套），
|
||||
// 绝不写构建期注入的内部署名。
|
||||
entryTemplateAuthor = "赛事积分榜系统"
|
||||
// entryTemplateHintRows 是输入提示覆盖的行数：模板是空表，给填表人留够行即可。
|
||||
entryTemplateHintRows = 500
|
||||
)
|
||||
|
||||
// entryTemplateJointHint 按表头语言取「联队怎么写」的说明（批注正文 + 输入提示的标题与正文）。
|
||||
func entryTemplateJointHint(language string) (hint, title, prompt string) {
|
||||
if language == "en" {
|
||||
return entryJointHintEN, entryJointTitleEN, entryJointPromptEN
|
||||
}
|
||||
return entryJointHintZH, entryJointTitleZH, entryJointPromptZH
|
||||
}
|
||||
|
||||
// entryTeamCodeColumn 是 team_code 在表头里的列号（0 起）。模板的说明挂在这一列上，
|
||||
// 所以它从 importColumns 现算，改了列序也不会挂错格子。
|
||||
func entryTeamCodeColumn() int {
|
||||
for i, column := range importColumns {
|
||||
if column.name == "team_code" {
|
||||
return i
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
// entryTemplateFilename 是两种表头语言的下载文件名，前端按同一份口径拼文件名。
|
||||
func entryTemplateFilename(language string) string {
|
||||
if language == "en" {
|
||||
@@ -488,9 +538,13 @@ func (s *server) entriesTemplateXLSX(w http.ResponseWriter, r *http.Request) (an
|
||||
}
|
||||
|
||||
headers := entryTemplateHeader(language)
|
||||
hint, hintTitle, prompt := entryTemplateJointHint(language)
|
||||
sheets := make([]entriesTemplateSheet, 0, len(plan.sheets))
|
||||
for _, planned := range plan.sheets {
|
||||
sheets = append(sheets, entriesTemplateSheet{Name: planned.Name, Headers: headers})
|
||||
sheets = append(sheets, entriesTemplateSheet{
|
||||
Name: planned.Name, Headers: headers,
|
||||
JointHint: hint, JointHintTitle: hintTitle, JointPrompt: prompt,
|
||||
})
|
||||
}
|
||||
name := entryTemplateFilename(language)
|
||||
ascii := "entries-template-" + language + ".xlsx"
|
||||
@@ -518,6 +572,11 @@ func entrySheetExcludedMessage(problems []string) string {
|
||||
type entriesTemplateSheet struct {
|
||||
Name string
|
||||
Headers []string
|
||||
// JointHint / JointHintTitle / JointPrompt 是「单位编码写 A+B」的说明（按表头语言取），
|
||||
// 挂在该列的批注与输入提示上。
|
||||
JointHint string
|
||||
JointHintTitle string
|
||||
JointPrompt string
|
||||
}
|
||||
|
||||
// writeEntriesTemplateXLSX 写整份模板工作簿。
|
||||
@@ -580,6 +639,9 @@ func writeEntriesTemplateXLSX(out io.Writer, sheets []entriesTemplateSheet) erro
|
||||
if err := f.SetRowHeight(sheet.Name, 1, 24); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := writeEntryJointTeamHint(f, sheet); err != nil {
|
||||
return err
|
||||
}
|
||||
// 冻结表头：一张表几十行，往下翻的时候列名得一直看得见。
|
||||
if err := f.SetPanes(sheet.Name, &excelize.Panes{
|
||||
Freeze: true, YSplit: 1, TopLeftCell: "A2", ActivePane: "bottomLeft",
|
||||
@@ -592,3 +654,45 @@ func writeEntriesTemplateXLSX(out io.Writer, sheets []entriesTemplateSheet) erro
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// writeEntryJointTeamHint 把「联队怎么写」挂在单位编码列上：表头那一格一条批注（有红三角），
|
||||
// 整列一条输入提示（点中格子就弹出）。
|
||||
//
|
||||
// 只动这两种载体，不碰任何单元格的值与行列结构：填好的表原样传回来时，导入器读到的仍是
|
||||
// 「第 1 行 12 列表头 + 数据行」，批注与输入提示不是数据。
|
||||
func writeEntryJointTeamHint(f *excelize.File, sheet entriesTemplateSheet) error {
|
||||
column := entryTeamCodeColumn()
|
||||
if column < 0 || column >= len(sheet.Headers) || sheet.JointHint == "" {
|
||||
return nil
|
||||
}
|
||||
name, err := excelize.ColumnNumberToName(column + 1)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := f.AddComment(sheet.Name, excelize.Comment{
|
||||
Cell: name + "1",
|
||||
Author: entryTemplateAuthor,
|
||||
Text: sheet.JointHint,
|
||||
Width: 360,
|
||||
Height: 170,
|
||||
}); err != nil {
|
||||
return fmt.Errorf("httpapi: 写模板批注 %s!%s1: %w", sheet.Name, name, err)
|
||||
}
|
||||
if sheet.JointPrompt == "" {
|
||||
return nil
|
||||
}
|
||||
// 刻意用 type="none"：这里只要一条提示，不要任何取值限制——现场的表千奇百怪，
|
||||
// 模板不该因为一条校验规则把好好的编码挡在门外。
|
||||
dv := excelize.NewDataValidation(true)
|
||||
dv.SetSqref(fmt.Sprintf("%s2:%s%d", name, name, entryTemplateHintRows))
|
||||
dv.Type = "none"
|
||||
title := sheet.JointHintTitle
|
||||
if title == "" {
|
||||
title = "单位编码"
|
||||
}
|
||||
dv.SetInput(title, sheet.JointPrompt)
|
||||
if err := f.AddDataValidation(sheet.Name, dv); err != nil {
|
||||
return fmt.Errorf("httpapi: 写模板输入提示 %s!%s: %w", sheet.Name, name, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,421 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"git.yeij.top/AskaEth/Scoreboard/server/internal/domain"
|
||||
"git.yeij.top/AskaEth/Scoreboard/server/internal/middleware"
|
||||
)
|
||||
|
||||
// 本文件是「联队 + 份额分成」的读写与解析（devdocs/19）。
|
||||
//
|
||||
// 表达方式：**联队是一条报名，不是一个新单位**。新建/修改报名时给多个成员单位（默认均分），
|
||||
// 分数与奖牌由引擎按份额下发到各单位；entries.team_id 仍是主单位（加号左边那个），
|
||||
// 既有查询、唯一键、榜单兜底都还认它。
|
||||
//
|
||||
// 与导入的关系：报名表的 team_code 列写 `A+B` 就是联队（默认均分），解析见 parseJointTeamCodes。
|
||||
|
||||
// maxJointTeamMembers 是联队的成员单位上限。现场最多见过三个单位合并，给到 5 已经远超需要；
|
||||
// 上限的作用是拦住「一整格都是加号」这类误填，而不是限制业务。
|
||||
const maxJointTeamMembers = 5
|
||||
|
||||
// parseJointTeamCodes 解析报名表 team_code 单元格：`A` → 单单位，`A+B` → 联队（A 是主单位）。
|
||||
//
|
||||
// 全角 ＋ 与两侧空格都当作分隔符的一部分（现场用中文输入法填表，打出来的常是全角），
|
||||
// 但**只做这一层归一**：分段为空（`A+`、`+B`、`A++B`）、重复（`A+A`）、超长一律报错。
|
||||
// 报错必须说清「这一格该怎么写」——现场看到一句「编码非法」是没法照着改的。
|
||||
func parseJointTeamCodes(raw string) ([]string, error) {
|
||||
normalized := strings.ReplaceAll(raw, "＋", "+")
|
||||
parts := strings.Split(normalized, "+")
|
||||
codes := make([]string, 0, len(parts))
|
||||
seen := make(map[string]bool, len(parts))
|
||||
for _, part := range parts {
|
||||
code := strings.TrimSpace(part)
|
||||
if code == "" {
|
||||
return nil, fmt.Errorf("单位编码 %s 里有一段是空的：联队要写成两个单位编码用 + 连起来（例如 A+B）", raw)
|
||||
}
|
||||
if seen[code] {
|
||||
return nil, fmt.Errorf("单位编码 %s 里同一个单位出现了两次：联队的每个单位只能写一次", raw)
|
||||
}
|
||||
seen[code] = true
|
||||
codes = append(codes, code)
|
||||
}
|
||||
if len(codes) > maxJointTeamMembers {
|
||||
return nil, fmt.Errorf("单位编码 %s 里写了 %d 个单位：一个联队最多 %d 个单位",
|
||||
raw, len(codes), maxJointTeamMembers)
|
||||
}
|
||||
return codes, nil
|
||||
}
|
||||
|
||||
// lookupImportTeams 把 team_code 解析成单位 id 与份额：普通报名一个单位，联队多个（默认均分）。
|
||||
//
|
||||
// 返回的份额就是写库要用的那套：每条权重 1（均分），medal 缺省（整枚各记）。
|
||||
// 主单位是 codes[0]（加号左边那个），它进 entries.team_id。
|
||||
//
|
||||
// 报错都是给现场看的行级文案，不包 apiError：调用方（导入主循环）用 err.Error() 原样回显，
|
||||
// 多一层前缀现场反而看不懂。单位不存在时必须点明是联队里的哪一段，否则一行 `A+B` 里
|
||||
// 找不到 B 的时候，录入员会以为是 A 写错了。
|
||||
func (s *server) lookupImportTeams(ctx context.Context, teamCode string) ([]int64, []entryTeamShareDTO, error) {
|
||||
codes, err := parseJointTeamCodes(teamCode)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
ids := make([]int64, 0, len(codes))
|
||||
shares := make([]entryTeamShareDTO, 0, len(codes))
|
||||
for _, code := range codes {
|
||||
id, err := s.lookupID(ctx, `SELECT id FROM teams WHERE code = ?`, code)
|
||||
if err != nil {
|
||||
if len(codes) > 1 {
|
||||
return nil, nil, fmt.Errorf("单位 %s 不存在（来自联队编码 %s）", code, teamCode)
|
||||
}
|
||||
return nil, nil, fmt.Errorf("单位 %s 不存在", code)
|
||||
}
|
||||
// 编码查单位时不排除已隐藏的（编码有唯一索引，排除会撞索引或重复建档），
|
||||
// 命中就复活他：这一行马上要给他建报名，人却看不见就说不通了。
|
||||
if err := s.reviveTeam(ctx, id); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
ids = append(ids, id)
|
||||
shares = append(shares, entryTeamShareDTO{TeamID: id, Weight: 1})
|
||||
}
|
||||
return ids, shares, nil
|
||||
}
|
||||
|
||||
// entryTeamSharesReady 判断份额表在不在。
|
||||
//
|
||||
// 读路径要能读「还没跑到 0024 的库」：迁移在服务启动时补跑（main.go），但榜单可能在迁移之前
|
||||
// 被读一次——0022 的老库回归用例就是在迁移前读榜的，它读的正是升级前那份错榜。
|
||||
// 表不在 = 库里没有任何联队配置 = 主单位独占 100%，正是老数据本来就该得到的结果，
|
||||
// 所以按「没有份额」处理是**精确**的，不是容错降级（份额表缺表时不可能丢掉真实配置）。
|
||||
func entryTeamSharesReady(ctx context.Context, q queryer) (bool, error) {
|
||||
var n int
|
||||
if err := q.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = 'entry_team_shares'`).Scan(&n); err != nil {
|
||||
return false, err
|
||||
}
|
||||
return n != 0, nil
|
||||
}
|
||||
|
||||
// loadEntryTeamSharesQ 读一条 SQL 里给定范围内报名的份额，按 entry_id 归组。
|
||||
// eventID 为 0 表示全库（导出与快照用，与它们读 channel_ranks 的范围一致）。
|
||||
//
|
||||
// 排序按 (sort_order, team_id)：主单位排第一是由写侧保证的，引擎不依赖顺序取分，
|
||||
// 但展示与流水顺序要稳定，否则同一份数据两次导出会排出两个样子。
|
||||
func loadEntryTeamSharesQ(ctx context.Context, q queryer, eventID int64) (map[int64][]domain.TeamShare, error) {
|
||||
ready, err := entryTeamSharesReady(ctx, q)
|
||||
if err != nil {
|
||||
return nil, internal(err)
|
||||
}
|
||||
if !ready {
|
||||
return nil, nil
|
||||
}
|
||||
query := `SELECT s.entry_id, s.team_id, s.points_share, s.medal_share
|
||||
FROM entry_team_shares s`
|
||||
args := []any{}
|
||||
if eventID != 0 {
|
||||
query += ` JOIN entries e ON e.id = s.entry_id WHERE e.event_id = ?`
|
||||
args = append(args, eventID)
|
||||
}
|
||||
query += ` ORDER BY s.entry_id, s.sort_order, s.team_id`
|
||||
|
||||
rows, err := q.QueryContext(ctx, query, args...)
|
||||
if err != nil {
|
||||
return nil, internal(err)
|
||||
}
|
||||
defer func() { _ = rows.Close() }()
|
||||
|
||||
out := make(map[int64][]domain.TeamShare)
|
||||
for rows.Next() {
|
||||
var (
|
||||
entryID int64
|
||||
s domain.TeamShare
|
||||
medal int
|
||||
)
|
||||
if err := rows.Scan(&entryID, &s.TeamID, &s.Weight, &medal); err != nil {
|
||||
return nil, internal(err)
|
||||
}
|
||||
if medal == 0 {
|
||||
excluded := false
|
||||
s.Medal = &excluded
|
||||
}
|
||||
out[entryID] = append(out[entryID], s)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// loadEntrySharesDTOs 读某小项全部报名的份额读数形态：带上单位编码 / 名称，
|
||||
// 前端据此拼「A+B联队」，不必再查一次单位表。
|
||||
func (s *server) loadEntrySharesDTOs(ctx context.Context, q queryer, eventID int64) (map[int64][]entryTeamShareDTO, error) {
|
||||
ready, err := entryTeamSharesReady(ctx, q)
|
||||
if err != nil {
|
||||
return nil, internal(err)
|
||||
}
|
||||
if !ready {
|
||||
return nil, nil
|
||||
}
|
||||
rows, err := q.QueryContext(ctx,
|
||||
`SELECT s.entry_id, s.team_id, s.points_share, s.medal_share, t.code, t.name
|
||||
FROM entry_team_shares s
|
||||
JOIN entries e ON e.id = s.entry_id
|
||||
JOIN teams t ON t.id = s.team_id
|
||||
WHERE e.event_id = ?
|
||||
ORDER BY s.entry_id, s.sort_order, s.team_id`, eventID)
|
||||
if err != nil {
|
||||
return nil, internal(err)
|
||||
}
|
||||
defer func() { _ = rows.Close() }()
|
||||
|
||||
out := make(map[int64][]entryTeamShareDTO)
|
||||
for rows.Next() {
|
||||
var (
|
||||
entryID int64
|
||||
item entryTeamShareDTO
|
||||
medal int
|
||||
)
|
||||
if err := rows.Scan(&entryID, &item.TeamID, &item.Weight, &medal, &item.TeamCode, &item.TeamName); err != nil {
|
||||
return nil, internal(err)
|
||||
}
|
||||
if medal == 0 {
|
||||
excluded := false
|
||||
item.Medal = &excluded
|
||||
}
|
||||
out[entryID] = append(out[entryID], item)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// entrySharesOf 把一条报名的份额补齐成「至少一条」：库里没有份额行时按主单位独占 100%。
|
||||
// 与引擎的 domain.ResolveShares 同口径（那边用 []domain.TeamShare，这边还要带展示字段）。
|
||||
// 主单位的编码 / 名称由调用方给（报名查询里本来就 join 了单位表）。
|
||||
func entrySharesOf(configured []entryTeamShareDTO, primaryTeamID int64, code, name string) []entryTeamShareDTO {
|
||||
if len(configured) > 0 {
|
||||
return configured
|
||||
}
|
||||
if primaryTeamID == 0 {
|
||||
return nil
|
||||
}
|
||||
return []entryTeamShareDTO{{TeamID: primaryTeamID, Weight: 1, TeamCode: code, TeamName: name}}
|
||||
}
|
||||
|
||||
// replaceEntryShares 按给定顺序重写一条报名的份额（先删后插，幂等）。
|
||||
//
|
||||
// 为什么每次都重写、而不是「有联队才写」：报名可以被改成另一个样子（联队改回单单位、
|
||||
// 换成员单位）。只增不减会留下旧份额，那条报名以后一直按早就改掉的配置分账。
|
||||
// 传空份额时按主单位独占补一条，保持「读侧至少一条」这个不变式。
|
||||
func replaceEntryShares(ctx context.Context, q queryer, entryID, primaryTeamID int64, shares []entryTeamShareDTO) error {
|
||||
if _, err := q.ExecContext(ctx, `DELETE FROM entry_team_shares WHERE entry_id = ?`, entryID); err != nil {
|
||||
return internal(err)
|
||||
}
|
||||
if len(shares) == 0 {
|
||||
shares = []entryTeamShareDTO{{TeamID: primaryTeamID, Weight: 1}}
|
||||
}
|
||||
for i, s := range shares {
|
||||
medal := 1
|
||||
if !entryShareCountsMedal(s) {
|
||||
medal = 0
|
||||
}
|
||||
if _, err := q.ExecContext(ctx,
|
||||
`INSERT INTO entry_team_shares (entry_id, team_id, points_share, medal_share, sort_order)
|
||||
VALUES (?, ?, ?, ?, ?)`,
|
||||
entryID, s.TeamID, entryShareWeight(s), medal, i); err != nil {
|
||||
return internal(err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// sharesContainTeam 判断份额里有没有这个单位（导入侧用它核对「主单位还在不在成员里」）。
|
||||
func sharesContainTeam(shares []entryTeamShareDTO, teamID int64) bool {
|
||||
for _, s := range shares {
|
||||
if s.TeamID == teamID {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// entryShareCountsMedal 与 domain.TeamShare.CountsMedal 同一口径：缺省（nil）= 整枚各记。
|
||||
func entryShareCountsMedal(s entryTeamShareDTO) bool {
|
||||
return s.Medal == nil || *s.Medal
|
||||
}
|
||||
|
||||
// entryShareWeight 与 domain 的 shareWeight 同一口径：0（不填）按 1 处理，也就是均分。
|
||||
// 负数在 validateEntryShares 就被拦下，这里的兜底只是让写库不会撞上 CHECK。
|
||||
func entryShareWeight(s entryTeamShareDTO) float64 {
|
||||
if s.Weight <= 0 {
|
||||
return 1
|
||||
}
|
||||
return s.Weight
|
||||
}
|
||||
|
||||
// validateEntryShares 校验一次份额改动，返回给人看的 400 错误。
|
||||
//
|
||||
// 规则（每一条都对着一种会算错分的写法）：
|
||||
// - 不能为空：份额为空等于没说清这条报名的分该给谁；
|
||||
// - 每个单位都得存在且没被假删除：删掉的单位不该再收分；
|
||||
// - 权重不能是负数：份额是相对权重，不填（0）就是 1——「均分」的写法，负数没有任何含义；
|
||||
// - 同一个单位只能出现一次：重复会让同一条成绩给同一个单位记两份分、两枚牌；
|
||||
// - 必须包含主单位（entries.team_id）：主单位是这条报名在库里的身份（唯一键用它），
|
||||
// 把它排除在份额之外，只会得到「报名挂在 A 头上、分全给了 B」这种看不见的错。
|
||||
func (s *server) validateEntryShares(ctx context.Context, primaryTeamID int64, shares []entryTeamShareDTO) error {
|
||||
if len(shares) == 0 {
|
||||
return badRequest("teamShares 不能为空：至少要有主单位一条", nil)
|
||||
}
|
||||
if len(shares) > maxJointTeamMembers {
|
||||
return badRequest(fmt.Sprintf("teamShares 最多 %d 个单位：一个联队不需要这么多成员", maxJointTeamMembers), nil)
|
||||
}
|
||||
ids := make([]int64, 0, len(shares))
|
||||
seen := make(map[int64]bool, len(shares))
|
||||
hasPrimary := false
|
||||
for i, s := range shares {
|
||||
if s.TeamID == 0 {
|
||||
return badRequest("teamShares[].teamId 必填", i)
|
||||
}
|
||||
if seen[s.TeamID] {
|
||||
return badRequest(fmt.Sprintf("teamShares 里单位 %d 出现了两次：同一个单位只能占一份", s.TeamID), i)
|
||||
}
|
||||
seen[s.TeamID] = true
|
||||
if s.Weight < 0 {
|
||||
return badRequest(fmt.Sprintf("teamShares[].weight 不能为负数（当前 %v）：份额是相对权重，不填或填 0 就按 1 算（均分）", s.Weight), i)
|
||||
}
|
||||
if s.TeamID == primaryTeamID {
|
||||
hasPrimary = true
|
||||
}
|
||||
ids = append(ids, s.TeamID)
|
||||
}
|
||||
if !hasPrimary {
|
||||
return badRequest(fmt.Sprintf("teamShares 必须包含这条报名的主单位 %d：主单位不能从份额里去掉（换主单位要重新建报名）", primaryTeamID), nil)
|
||||
}
|
||||
|
||||
args := make([]any, 0, len(ids))
|
||||
for _, id := range ids {
|
||||
args = append(args, id)
|
||||
}
|
||||
rows, err := s.ev.QueryContext(ctx,
|
||||
`SELECT id FROM teams WHERE deleted_at IS NULL AND id IN (`+placeholders(len(ids))+`)`, args...)
|
||||
if err != nil {
|
||||
return internal(err)
|
||||
}
|
||||
defer func() { _ = rows.Close() }()
|
||||
exists := make(map[int64]bool, len(ids))
|
||||
for rows.Next() {
|
||||
var id int64
|
||||
if err := rows.Scan(&id); err != nil {
|
||||
return internal(err)
|
||||
}
|
||||
exists[id] = true
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return err
|
||||
}
|
||||
missing := make([]int64, 0)
|
||||
for _, id := range ids {
|
||||
if !exists[id] {
|
||||
missing = append(missing, id)
|
||||
}
|
||||
}
|
||||
if len(missing) > 0 {
|
||||
return badRequest("teamId 不存在或已删除", missing)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// loadEntryForShares 读一条报名的落点（小项 / 组别 / 主单位），份额改动要用它决定重算范围。
|
||||
func (s *server) loadEntryForShares(ctx context.Context, entryID int64) (eventID, categoryID, teamID int64, err error) {
|
||||
err = s.ev.QueryRowContext(ctx,
|
||||
`SELECT event_id, category_id, team_id FROM entries WHERE id = ?`, entryID).
|
||||
Scan(&eventID, &categoryID, &teamID)
|
||||
if err == sql.ErrNoRows {
|
||||
return 0, 0, 0, notFound("报名项不存在")
|
||||
}
|
||||
if err != nil {
|
||||
return 0, 0, 0, internal(err)
|
||||
}
|
||||
return eventID, categoryID, teamID, nil
|
||||
}
|
||||
|
||||
// updateEntryTeamShares 改写一条报名的份额并重算它所在的小项组别。
|
||||
//
|
||||
// 必须重算：份额决定同一条成绩的分记在谁头上，不重算就是「界面显示改好了、榜单还是旧分」。
|
||||
// 奖牌不需要单独处理——它由读取侧按 entry_team_shares 现算，落地即生效。
|
||||
func (s *server) updateEntryTeamShares(ctx context.Context, entryID int64, shares []entryTeamShareDTO, actorID int64) (entryDTO, error) {
|
||||
eventID, categoryID, teamID, err := s.loadEntryForShares(ctx, entryID)
|
||||
if err != nil {
|
||||
return entryDTO{}, err
|
||||
}
|
||||
if err := s.validateEntryShares(ctx, teamID, shares); err != nil {
|
||||
return entryDTO{}, err
|
||||
}
|
||||
|
||||
tx, err := s.ev.BeginTx(ctx, nil)
|
||||
if err != nil {
|
||||
return entryDTO{}, internal(err)
|
||||
}
|
||||
defer func() { _ = tx.Rollback() }()
|
||||
|
||||
if err := replaceEntryShares(ctx, tx, entryID, teamID, shares); err != nil {
|
||||
return entryDTO{}, err
|
||||
}
|
||||
score, err := recomputeLedgerTx(ctx, tx, eventID, categoryID, actorID, "报名份额变更后重算")
|
||||
if err != nil {
|
||||
return entryDTO{}, err
|
||||
}
|
||||
if err := applyComputedRanks(ctx, tx, score.Ranked); err != nil {
|
||||
return entryDTO{}, err
|
||||
}
|
||||
if err := s.bumpEvent(ctx, tx, eventID); err != nil {
|
||||
return entryDTO{}, err
|
||||
}
|
||||
if err := s.bumpStandings(ctx, tx, actorID); err != nil {
|
||||
return entryDTO{}, err
|
||||
}
|
||||
if err := tx.Commit(); err != nil {
|
||||
return entryDTO{}, internal(err)
|
||||
}
|
||||
return s.getEntry(ctx, entryID)
|
||||
}
|
||||
|
||||
// getEntry 读回单条报名（含份额），供份额改写接口回显。
|
||||
func (s *server) getEntry(ctx context.Context, entryID int64) (entryDTO, error) {
|
||||
e, err := scanEntry(s.ev.QueryRowContext(ctx, entrySelect+` WHERE e.id = ?`, entryID))
|
||||
if err != nil {
|
||||
if err == sql.ErrNoRows {
|
||||
return entryDTO{}, notFound("报名项不存在")
|
||||
}
|
||||
return entryDTO{}, internal(err)
|
||||
}
|
||||
shares, err := s.loadEntrySharesDTOs(ctx, s.ev, e.EventID)
|
||||
if err != nil {
|
||||
return entryDTO{}, err
|
||||
}
|
||||
e.TeamShares = entrySharesOf(shares[e.ID], e.TeamID, e.TeamCode, e.TeamName)
|
||||
return e, nil
|
||||
}
|
||||
|
||||
// updateEntryTeamSharesHandler 是 PUT /api/entries/{id}/team-shares：
|
||||
// 改一条报名的成员单位与权重（联队），成功后返回这条报名的完整读数。
|
||||
func (s *server) updateEntryTeamSharesHandler(w http.ResponseWriter, r *http.Request) (any, error) {
|
||||
id, err := pathID(r, "id")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var in entryTeamSharesPayload
|
||||
if err := decodeJSON(r, &in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
before, err := s.getEntry(r.Context(), id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
updated, err := s.updateEntryTeamShares(r.Context(), id, in.TeamShares, middleware.User(r.Context()).ID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
s.audit(r.Context(), "entry.team_shares.update", "entry", id,
|
||||
map[string]any{"teamShares": before.TeamShares}, map[string]any{"teamShares": updated.TeamShares})
|
||||
return updated, nil
|
||||
}
|
||||
@@ -0,0 +1,396 @@
|
||||
package httpapi_test
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// 本文件钉住「联队 + 份额分成」从导入到榜单的完整链路（devdocs/19）：
|
||||
// - 报名表 team_code 写 `A+B` → 一条报名挂两个单位（默认均分），主单位是加号左边那个；
|
||||
// - 团体第 1 名 15 分 → 两个单位各 7.5 分；金牌两个单位**各记 1 枚**（不是各 0.5 枚）；
|
||||
// - 权重可配（2:1 → 10 / 5），改完当场重算推榜；
|
||||
// - 非法写法（单位不存在 / 缺一段 / 重复 / 太多）必须拦下并给出照得着改的报错。
|
||||
|
||||
// seedMatchEvent 造一个「球类」小项：match 类型 + 按单位录名次的团体通道
|
||||
// （规则包给 match 的模板就是 scope=team + basis=manual），返回小项与组别 id。
|
||||
func seedMatchEvent(t *testing.T, env *testEnv, ids seedIDs) (eventID, categoryID int64) {
|
||||
t.Helper()
|
||||
eventID = env.insert(t, `INSERT INTO events (sport_id, code, name, event_type, result_mode, result_type,
|
||||
compare, scored, multiplier, status)
|
||||
VALUES (?, 'BALL', '篮球', 'match', 'manual', 'count', 'none', 1, 1, 'ongoing')`, ids.sport)
|
||||
categoryID = env.insert(t, `INSERT INTO event_categories (event_id, name, multiplier, sort_order)
|
||||
VALUES (?, '男子', 1, 0)`, eventID)
|
||||
env.exec(t, `INSERT INTO event_score_channels (event_id, scope, basis, profile_id, sort_order)
|
||||
VALUES (?, 'team', 'manual', ?, 0)`, eventID, profileIDByCode(t, env, "team_top6"))
|
||||
return eventID, categoryID
|
||||
}
|
||||
|
||||
// jointImportRow 拼一行团体报名（无姓名 = 团体行），列序与 importHeader 一致。
|
||||
func jointImportRow(eventCode, category, teamCode string) string {
|
||||
return strings.Join([]string{eventCode, category, teamCode, "", "", "", "", "", "", "registered", "张伟/李强"}, ",")
|
||||
}
|
||||
|
||||
// importCSV 上传一份单表 CSV（表头 + 若干行）。
|
||||
func importCSV(t *testing.T, env *testEnv, client *http.Client, rows ...string) (int, envelope) {
|
||||
t.Helper()
|
||||
content := importHeader + "\n" + strings.Join(rows, "\n") + "\n"
|
||||
return env.postImport(t, client, "/api/entries/import", content, "")
|
||||
}
|
||||
|
||||
// sharesDump 导出某小项「报名 + 份额」的原始落库事实（列序见下面的查询）：
|
||||
// share_team 为 "<nil>" 表示这条报名一条份额都没有（不该出现）。
|
||||
func sharesDump(t *testing.T, env *testEnv, eventID int64) string {
|
||||
t.Helper()
|
||||
return tableDump(t, env, fmt.Sprintf(
|
||||
`SELECT e.id AS entry_id, COALESCE(e.athlete_id, 0) AS athlete_id, e.team_id,
|
||||
COALESCE(s.team_id, 0) AS share_team, COALESCE(s.points_share, 0) AS points_share,
|
||||
COALESCE(s.medal_share, 0) AS medal_share, COALESCE(s.sort_order, 0) AS sort_order
|
||||
FROM entries e
|
||||
LEFT JOIN entry_team_shares s ON s.entry_id = e.id
|
||||
WHERE e.event_id = %d
|
||||
ORDER BY e.id, s.sort_order, s.team_id`, eventID))
|
||||
}
|
||||
|
||||
// shareRow 按 tableDump 的格式拼一行份额（列名=值，行尾一个空格）。
|
||||
func shareRow(entryID, athleteID, teamID, shareTeam int64, weight float64, medal, order int) string {
|
||||
return fmt.Sprintf("entry_id=%d athlete_id=%d team_id=%d share_team=%d points_share=%v medal_share=%d sort_order=%d \n",
|
||||
entryID, athleteID, teamID, shareTeam, weight, medal, order)
|
||||
}
|
||||
|
||||
// shareAbsentRow 是「这条报名一条份额行都没有」的 dump 行：种子 / 手工造的报名直接写 entries，
|
||||
// 绕过了导入，库里就没有份额行——读侧与引擎都按主单位独占 100% 兜底（老数据同理）。
|
||||
func shareAbsentRow(entryID, athleteID, teamID int64) string {
|
||||
return fmt.Sprintf("entry_id=%d athlete_id=%d team_id=%d share_team=0 points_share=0 medal_share=0 sort_order=0 \n",
|
||||
entryID, athleteID, teamID)
|
||||
}
|
||||
|
||||
// firstEntryID 取某小项的第一条报名 id。
|
||||
func firstEntryID(t *testing.T, env *testEnv, eventID int64) int64 {
|
||||
t.Helper()
|
||||
var id int64
|
||||
if err := env.ev.QueryRow(`SELECT id FROM entries WHERE event_id = ? ORDER BY id LIMIT 1`, eventID).Scan(&id); err != nil {
|
||||
t.Fatalf("读报名项: %v", err)
|
||||
}
|
||||
return id
|
||||
}
|
||||
|
||||
// standingsRow 取积分榜上某个单位那一行（REST /api/standings 的原始读数）。
|
||||
func standingsRow(t *testing.T, env *testEnv, client *http.Client, teamID int64) map[string]any {
|
||||
t.Helper()
|
||||
status, resp := env.do(client, http.MethodGet, "/api/standings", nil, false)
|
||||
if status != http.StatusOK || !resp.OK {
|
||||
t.Fatalf("读积分榜应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
for _, row := range decodeData[[]map[string]any](t, resp) {
|
||||
if row["teamId"] == float64(teamID) {
|
||||
return row
|
||||
}
|
||||
}
|
||||
t.Fatalf("积分榜上没有单位 %d", teamID)
|
||||
return nil
|
||||
}
|
||||
|
||||
// assertStanding 断言某单位的总分与金银铜。
|
||||
func assertStanding(t *testing.T, env *testEnv, client *http.Client, teamID int64, points float64, gold, silver, bronze int) {
|
||||
t.Helper()
|
||||
row := standingsRow(t, env, client, teamID)
|
||||
if got := row["totalPoints"].(float64); got != points {
|
||||
t.Errorf("单位 %d 总分 = %v，期望 %v（整行：%+v）", teamID, got, points, row)
|
||||
}
|
||||
for name, want := range map[string]int{"gold": gold, "silver": silver, "bronze": bronze} {
|
||||
if got := row[name].(float64); got != float64(want) {
|
||||
t.Errorf("单位 %d 的 %s = %v，期望 %d（整行：%+v）", teamID, name, got, want, row)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 现场场景：两个单位因人数不足合并参赛，团体第 1 名 15 分 → A、B 各 7.5 分、各 1 枚金牌。
|
||||
func TestImportJointTeamSplitsPointsAndMedals(t *testing.T) {
|
||||
env, ids, client := recorderWithSeed(t)
|
||||
eventID, categoryID := seedMatchEvent(t, env, ids)
|
||||
|
||||
status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A+B"))
|
||||
if status != http.StatusOK || !resp.OK {
|
||||
t.Fatalf("导入联队报名应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
if result := decodeData[map[string]any](t, resp); result["created"].(float64) != 1 {
|
||||
t.Fatalf("应新建 1 条报名，得到 %+v", result)
|
||||
}
|
||||
|
||||
// 主单位是加号左边那个（A），份额表里两条均分、奖牌各记整枚。
|
||||
entryID := firstEntryID(t, env, eventID)
|
||||
want := shareRow(entryID, 0, ids.teamA, ids.teamA, 1, 1, 0) +
|
||||
shareRow(entryID, 0, ids.teamA, ids.teamB, 1, 1, 1)
|
||||
if got := sharesDump(t, env, eventID); got != want {
|
||||
t.Fatalf("联队报名落库不对：\n得到 %s期望 %s", got, want)
|
||||
}
|
||||
|
||||
// 团体名次录在主单位上（现场就是按单位录名次）：联队第 1 名。
|
||||
if status, resp := putTeamRanks(t, env, client, eventID, categoryID, []map[string]any{
|
||||
{"teamId": ids.teamA, "rank": 1},
|
||||
}); status != http.StatusOK {
|
||||
t.Fatalf("录团体名次应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
|
||||
// 积分各 7.5（允许出现小数），金牌各 1 枚。
|
||||
assertStanding(t, env, client, ids.teamA, 7.5, 1, 0, 0)
|
||||
assertStanding(t, env, client, ids.teamB, 7.5, 1, 0, 0)
|
||||
|
||||
ledger := tableDump(t, env, `SELECT team_id, points FROM score_ledger WHERE voided = 0 ORDER BY team_id`)
|
||||
wantLedger := fmt.Sprintf("team_id=%d points=7.5 \nteam_id=%d points=7.5 \n", ids.teamA, ids.teamB)
|
||||
if ledger != wantLedger {
|
||||
t.Fatalf("积分流水应按份额拆成两条：\n得到 %s期望 %s", ledger, wantLedger)
|
||||
}
|
||||
}
|
||||
|
||||
// 权重可配：改成 2:1 → 10 / 5；奖牌仍是各 1 枚（两个口径互不影响）。
|
||||
func TestUpdateEntryTeamSharesWeights(t *testing.T) {
|
||||
env, ids, client := recorderWithSeed(t)
|
||||
eventID, categoryID := seedMatchEvent(t, env, ids)
|
||||
if status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A+B")); status != http.StatusOK {
|
||||
t.Fatalf("导入联队报名应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
entryID := firstEntryID(t, env, eventID)
|
||||
if status, resp := putTeamRanks(t, env, client, eventID, categoryID, []map[string]any{
|
||||
{"teamId": ids.teamA, "rank": 1},
|
||||
}); status != http.StatusOK {
|
||||
t.Fatalf("录团体名次应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
assertStanding(t, env, client, ids.teamA, 7.5, 1, 0, 0)
|
||||
|
||||
path := fmt.Sprintf("/api/entries/%d/team-shares", entryID)
|
||||
status, resp := env.do(client, http.MethodPut, path, map[string]any{
|
||||
"teamShares": []map[string]any{
|
||||
{"teamId": ids.teamA, "weight": 2},
|
||||
{"teamId": ids.teamB, "weight": 1},
|
||||
},
|
||||
}, true)
|
||||
if status != http.StatusOK || !resp.OK {
|
||||
t.Fatalf("改份额应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
updated := decodeData[map[string]any](t, resp)
|
||||
shares, _ := updated["teamShares"].([]any)
|
||||
if len(shares) != 2 {
|
||||
t.Fatalf("回显应带两条份额，得到 %+v", updated["teamShares"])
|
||||
}
|
||||
first, _ := shares[0].(map[string]any)
|
||||
if first["teamId"] != float64(ids.teamA) || first["weight"] != float64(2) {
|
||||
t.Fatalf("回显的第一条应是主单位 A 权重 2，得到 %+v", first)
|
||||
}
|
||||
if first["teamCode"] != "A" || first["teamName"] != "第一分公司" {
|
||||
t.Fatalf("回显应带上单位编码与名称（前端拼「A+B联队」用），得到 %+v", first)
|
||||
}
|
||||
|
||||
// 改完当场重算：2:1 拆成 10 / 5，奖牌不受权重影响，仍是各 1 枚。
|
||||
assertStanding(t, env, client, ids.teamA, 10, 1, 0, 0)
|
||||
assertStanding(t, env, client, ids.teamB, 5, 1, 0, 0)
|
||||
|
||||
// 奖牌开关按单位存（medal=false 落成 medal_share=0 再读回来），积分照旧按权重拆。
|
||||
status, resp = env.do(client, http.MethodPut, path, map[string]any{
|
||||
"teamShares": []map[string]any{
|
||||
{"teamId": ids.teamA, "weight": 2},
|
||||
{"teamId": ids.teamB, "weight": 1, "medal": false},
|
||||
},
|
||||
}, true)
|
||||
if status != http.StatusOK || !resp.OK {
|
||||
t.Fatalf("关掉成员单位的奖牌应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
shares, _ = decodeData[map[string]any](t, resp)["teamShares"].([]any)
|
||||
second, _ := shares[1].(map[string]any)
|
||||
if second["medal"] != false {
|
||||
t.Fatalf("回显应带上「这个单位不记奖牌」（medal:false），得到 %+v", second)
|
||||
}
|
||||
assertStanding(t, env, client, ids.teamA, 10, 1, 0, 0)
|
||||
assertStanding(t, env, client, ids.teamB, 5, 0, 0, 0)
|
||||
}
|
||||
|
||||
// 非法份额的报错必须说清怎么改（人话），且一律不落库。
|
||||
func TestUpdateEntryTeamSharesRejectsBadPayloads(t *testing.T) {
|
||||
env, ids, client := recorderWithSeed(t)
|
||||
eventID, _ := seedMatchEvent(t, env, ids)
|
||||
if status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A")); status != http.StatusOK {
|
||||
t.Fatalf("导入单人报名应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
entryID := firstEntryID(t, env, eventID)
|
||||
path := fmt.Sprintf("/api/entries/%d/team-shares", entryID)
|
||||
baseline := tableDump(t, env, `SELECT team_id, points_share FROM entry_team_shares ORDER BY team_id`)
|
||||
|
||||
cases := []struct {
|
||||
name string
|
||||
body map[string]any
|
||||
want string
|
||||
}{
|
||||
{"空份额", map[string]any{"teamShares": []map[string]any{}}, "teamShares 不能为空"},
|
||||
{"缺主单位", map[string]any{"teamShares": []map[string]any{{"teamId": ids.teamB}}}, "必须包含这条报名的主单位"},
|
||||
{"单位重复", map[string]any{"teamShares": []map[string]any{
|
||||
{"teamId": ids.teamA}, {"teamId": ids.teamA}}}, "出现了两次"},
|
||||
{"权重为负", map[string]any{"teamShares": []map[string]any{
|
||||
{"teamId": ids.teamA, "weight": -1}}}, "不能为负数"},
|
||||
{"单位不存在", map[string]any{"teamShares": []map[string]any{
|
||||
{"teamId": ids.teamA}, {"teamId": 999999}}}, "不存在或已删除"},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
status, resp := env.do(client, http.MethodPut, path, tc.body, true)
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("应 400，得到 %d %+v", status, resp)
|
||||
}
|
||||
if resp.Error == nil || !strings.Contains(resp.Error.Message, tc.want) {
|
||||
t.Fatalf("报错应含 %q，得到 %+v", tc.want, resp.Error)
|
||||
}
|
||||
// 拦下就不能落库：份额表必须一个字节都没动。
|
||||
if got := tableDump(t, env, `SELECT team_id, points_share FROM entry_team_shares ORDER BY team_id`); got != baseline {
|
||||
t.Fatalf("被拒的请求改动了份额表：\n之前 %s之后 %s", baseline, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// 报名表里非法写法的联队：拦下这一行并给出照得着改的报错，其余行照常导入。
|
||||
func TestImportJointTeamRejectsBadForms(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
teamCode string
|
||||
want string
|
||||
}{
|
||||
{"成员单位不存在", "A+ZZ", "单位 ZZ 不存在（来自联队编码 A+ZZ）"},
|
||||
{"加号后面缺一段", "A+", "里有一段是空的"},
|
||||
{"加号前面缺一段", "+B", "里有一段是空的"},
|
||||
{"同一个单位写两遍", "A+A", "同一个单位出现了两次"},
|
||||
{"成员太多", "A+B+C+D+E+F", "一个联队最多 5 个单位"},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
env, ids, client := recorderWithSeed(t)
|
||||
eventID, _ := seedMatchEvent(t, env, ids)
|
||||
|
||||
// 前面一行是正常的单单位报名：它必须照常导入（坏行不能拖垮整张表）。
|
||||
status, resp := importCSV(t, env, client,
|
||||
jointImportRow("BALL", "男子", "A"),
|
||||
jointImportRow("BALL", "男子", tc.teamCode),
|
||||
)
|
||||
if status != http.StatusOK || !resp.OK {
|
||||
t.Fatalf("导入端点应 200（逐行报错），得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
result := decodeData[map[string]any](t, resp)
|
||||
if result["created"].(float64) != 1 || result["skipped"].(float64) != 1 {
|
||||
t.Fatalf("应 1 条成功 1 条跳过，得到 %+v", result)
|
||||
}
|
||||
errs, _ := result["errors"].([]any)
|
||||
if len(errs) != 1 || !strings.Contains(fmt.Sprint(errs[0]), tc.want) {
|
||||
t.Fatalf("第 2 行的报错应含 %q，得到 %+v", tc.want, errs)
|
||||
}
|
||||
if n := countRows(t, env, `SELECT COUNT(*) FROM entries WHERE event_id = ?`, eventID); n != 1 {
|
||||
t.Fatalf("坏行不该落库，报名数 = %d（明细：\n%s）", n, sharesDump(t, env, eventID))
|
||||
}
|
||||
// 成功那行必须是「主单位独占」一条：坏行的解析结果不能污染它。
|
||||
entryID := firstEntryID(t, env, eventID)
|
||||
want := shareRow(entryID, 0, ids.teamA, ids.teamA, 1, 1, 0)
|
||||
if got := sharesDump(t, env, eventID); got != want {
|
||||
t.Fatalf("正常行应只挂主单位一条份额：\n得到 %s期望 %s", got, want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// 全角加号与两侧空格照样认（现场用中文输入法填表，打出来的常是全角）。
|
||||
func TestImportJointTeamAcceptsFullWidthPlus(t *testing.T) {
|
||||
env, ids, client := recorderWithSeed(t)
|
||||
eventID, _ := seedMatchEvent(t, env, ids)
|
||||
if status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A ＋ B")); status != http.StatusOK {
|
||||
t.Fatalf("导入应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
entryID := firstEntryID(t, env, eventID)
|
||||
want := shareRow(entryID, 0, ids.teamA, ids.teamA, 1, 1, 0) +
|
||||
shareRow(entryID, 0, ids.teamA, ids.teamB, 1, 1, 1)
|
||||
if got := sharesDump(t, env, eventID); got != want {
|
||||
t.Fatalf("全角加号应解析成同一个联队：\n得到 %s期望 %s", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
// 联队改回单单位（或换成员单位）时份额必须跟着变：只增不改会把旧配置一直用下去。
|
||||
func TestImportJointTeamResetsSharesOnReimport(t *testing.T) {
|
||||
env, ids, client := recorderWithSeed(t)
|
||||
eventID, _ := seedMatchEvent(t, env, ids)
|
||||
if status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A+B")); status != http.StatusOK {
|
||||
t.Fatalf("导入联队报名应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A"))
|
||||
if status != http.StatusOK || !resp.OK {
|
||||
t.Fatalf("重传单单位应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
if result := decodeData[map[string]any](t, resp); result["updated"].(float64) != 1 {
|
||||
t.Fatalf("应更新同一行，得到 %+v", result)
|
||||
}
|
||||
entryID := firstEntryID(t, env, eventID)
|
||||
want := shareRow(entryID, 0, ids.teamA, ids.teamA, 1, 1, 0)
|
||||
if got := sharesDump(t, env, eventID); got != want {
|
||||
t.Fatalf("改回单单位后份额应只剩主单位一条：\n得到 %s期望 %s", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
// 单个单位的报名照旧：库里写一条「主单位独占 100%」，读接口也下发一条，前端不必分支。
|
||||
func TestSingleUnitEntryKeepsWholeShare(t *testing.T) {
|
||||
env, ids, client := recorderWithSeed(t)
|
||||
eventID, categoryID := seedMatchEvent(t, env, ids)
|
||||
if status, resp := importCSV(t, env, client, jointImportRow("BALL", "男子", "A")); status != http.StatusOK {
|
||||
t.Fatalf("导入应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
entryID := firstEntryID(t, env, eventID)
|
||||
want := shareRow(entryID, 0, ids.teamA, ids.teamA, 1, 1, 0)
|
||||
if got := sharesDump(t, env, eventID); got != want {
|
||||
t.Fatalf("单单位报名应写一条独占份额：\n得到 %s期望 %s", got, want)
|
||||
}
|
||||
|
||||
board := getEntryBoard(t, env, client, eventID)
|
||||
if len(board.Entries) != 1 {
|
||||
t.Fatalf("应有一条报名，得到 %+v", board.Entries)
|
||||
}
|
||||
shares, _ := board.Entries[0]["teamShares"].([]any)
|
||||
if len(shares) != 1 {
|
||||
t.Fatalf("读接口应下发一条份额（普通报名也一样），得到 %+v", board.Entries[0]["teamShares"])
|
||||
}
|
||||
share, _ := shares[0].(map[string]any)
|
||||
if share["teamId"] != float64(ids.teamA) || share["weight"] != float64(1) || share["teamCode"] != "A" {
|
||||
t.Fatalf("份额读数应为 {teamId:A, weight:1, teamCode:A}，得到 %+v", share)
|
||||
}
|
||||
|
||||
// 独占口径下名次与积分照旧：第 1 名 15 分全给 A，B 一分没有。
|
||||
if status, resp := putTeamRanks(t, env, client, eventID, categoryID, []map[string]any{
|
||||
{"teamId": ids.teamA, "rank": 1},
|
||||
}); status != http.StatusOK {
|
||||
t.Fatalf("录团体名次应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
assertStanding(t, env, client, ids.teamA, 15, 1, 0, 0)
|
||||
assertStanding(t, env, client, ids.teamB, 0, 0, 0, 0)
|
||||
}
|
||||
|
||||
// 人员匹配可能把报名改挂到库里那条档案的单位（keep-existing 的既有口径「报名跟随库里已有的单位」）：
|
||||
// 份额必须跟着**最终主单位**走。跟不上的话就会出现「报名挂在 A 名下、分却记给了表格里写的 B」——
|
||||
// 现场看不出来，但榜单直接是错的。
|
||||
func TestImportSharesFollowMatchedUnit(t *testing.T) {
|
||||
env, ids, client := recorderWithSeed(t)
|
||||
env.exec(t, `UPDATE athletes SET id_card = '110101199001011234', bib = 'A100' WHERE id = ?`, ids.athleteA)
|
||||
|
||||
// 表里写 B，库里这个人的单位是 A，用户选 keep-existing → 报名仍挂在 A。
|
||||
body := importHeader + "\nM100,男子,B,张伟,110101199001011234,男,,A100,,registered,\n"
|
||||
decisions := `[{"idCard":"110101199001011234","action":"keep-existing"}]`
|
||||
status, resp := env.postImport(t, client, "/api/entries/import/resolve", body, decisions)
|
||||
if status != http.StatusOK || !resp.OK {
|
||||
t.Fatalf("决策导入应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
|
||||
want := shareRow(ids.entryA, ids.athleteA, ids.teamA, ids.teamA, 1, 1, 0) +
|
||||
shareAbsentRow(ids.entryB, ids.athB, ids.teamB)
|
||||
if got := sharesDump(t, env, ids.event); got != want {
|
||||
t.Fatalf("份额应跟随最终主单位 A：\n得到 %s期望 %s", got, want)
|
||||
}
|
||||
|
||||
// 榜单上分也只能记给 A：报名挂在 A 名下，B 一分没有。
|
||||
publishResults(t, env, client, ids.event, "shares-follow-matched-unit",
|
||||
map[string]any{"entryId": ids.entryA, "resultValue": 11.2, "resultText": "11.2", "unit": "秒", "status": "ok"})
|
||||
assertStanding(t, env, client, ids.teamA, 10, 1, 0, 0)
|
||||
assertStanding(t, env, client, ids.teamB, 0, 0, 0, 0)
|
||||
}
|
||||
@@ -1291,19 +1291,16 @@ func (s *server) importEntriesWith(ctx context.Context, sheets []importSheet, de
|
||||
continue
|
||||
}
|
||||
}
|
||||
teamID, err := s.lookupID(ctx, `SELECT id FROM teams WHERE code = ?`, teamCode)
|
||||
// team_code 写 `A+B` 就是联队（devdocs/19）：解析出多个成员单位，第一个是主单位，
|
||||
// 分与奖牌按份额下发给各单位。成员单位的存在性、复活与报错都在里面，
|
||||
// 报错文案与单单位口径逐字一致（现场几百份老表的提示格式不该变样）。
|
||||
teamIDs, teamShares, err := s.lookupImportTeams(ctx, teamCode)
|
||||
if err != nil {
|
||||
result.Skipped++
|
||||
result.Errors = append(result.Errors, prefix+s.interceptRow(line, "单位 %s 不存在", teamCode))
|
||||
continue
|
||||
}
|
||||
// 编码查单位时不排除已隐藏的（编码有唯一索引，排除会撞索引或重复建档），
|
||||
// 命中就复活他：这一行马上要给他建报名，人却看不见就说不通了。
|
||||
if err := s.reviveTeam(ctx, teamID); err != nil {
|
||||
result.Skipped++
|
||||
result.Errors = append(result.Errors, prefix+s.interceptRow(line, "%s", err.Error()))
|
||||
continue
|
||||
}
|
||||
teamID := teamIDs[0]
|
||||
if table.scope == nil {
|
||||
if categoryName != "" {
|
||||
categoryID, err = s.lookupID(ctx, `SELECT id FROM event_categories WHERE event_id = ? AND name = ?`, eventID, categoryName)
|
||||
@@ -1427,10 +1424,19 @@ func (s *server) importEntriesWith(ctx context.Context, sheets []importSheet, de
|
||||
teamID = matched.TeamID
|
||||
}
|
||||
|
||||
// 份额必须跟着**最终**的主单位走：上面的人员匹配可能把报名改挂到库里那条档案的单位
|
||||
// （keep-existing 的既有口径「报名跟随库里已有的单位」）。主单位掉到表格写的成员之外时
|
||||
// 整组退回独占，与升级前一致——报名挂在哪个单位，分就记给哪个单位；
|
||||
// 否则会出现「报名挂在 A 名下、分却记给了表格里写的 B」这种看不见的错。
|
||||
if !sharesContainTeam(teamShares, teamID) {
|
||||
teamShares = nil
|
||||
}
|
||||
|
||||
outcome, err := s.upsertImportedEntry(ctx, entryDTO{
|
||||
EventID: eventID,
|
||||
CategoryID: categoryID,
|
||||
TeamID: teamID,
|
||||
TeamShares: teamShares,
|
||||
AthleteID: athleteID,
|
||||
MemberNames: splitNames(cell("member_names")),
|
||||
Bib: nilIfEmpty(bib),
|
||||
|
||||
@@ -0,0 +1,101 @@
|
||||
package httpapi_test
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// 报名模板要让填表人知道联队怎么写（devdocs/19）：单位编码写 `A+B`，加号左边那个是主单位，
|
||||
// 积分平均分、奖牌两边各记一枚。
|
||||
//
|
||||
// 说明只能挂在「不会变成数据」的载体上：表头行是导入器认模板的锚点（必须留在第 1 行、
|
||||
// 12 列一成不变），工作表名是「小项@组别」的范围锚点（也不能多出说明表），
|
||||
// 所以这里用**单元格批注**（表头「单位编码」那一格）+ **该列的输入提示**（选中即弹出）。
|
||||
func TestEntriesTemplateExplainsJointTeamCode(t *testing.T) {
|
||||
env, _, client := recorderWithSeed(t)
|
||||
|
||||
for _, lang := range []string{"zh", "en"} {
|
||||
f, _ := env.fetchTemplate(t, client, lang)
|
||||
sheets := f.GetSheetList()
|
||||
if len(sheets) == 0 {
|
||||
t.Fatalf("lang=%s 模板没有工作表", lang)
|
||||
}
|
||||
for _, sheet := range sheets {
|
||||
comments, err := f.GetComments(sheet)
|
||||
if err != nil {
|
||||
t.Fatalf("[%s] 读工作表 %s 的批注: %v", lang, sheet, err)
|
||||
}
|
||||
if len(comments) != 1 {
|
||||
t.Fatalf("[%s] 工作表 %s 应有且仅有 1 条批注（挂在单位编码表头），得到 %d 条", lang, sheet, len(comments))
|
||||
}
|
||||
comment := comments[0]
|
||||
if comment.Cell != "C1" {
|
||||
t.Errorf("[%s] 批注应挂在单位编码表头 C1，得到 %s", lang, comment.Cell)
|
||||
}
|
||||
if !strings.Contains(comment.Text, "A+B") {
|
||||
t.Errorf("[%s] 批注没写清联队怎么写：%q", lang, comment.Text)
|
||||
}
|
||||
// 批注作者写系统名（与导出件的文档属性同一套），不是构建期注入的内部署名。
|
||||
if comment.Author != "赛事积分榜系统" {
|
||||
t.Errorf("[%s] 批注作者 = %q，期望系统名", lang, comment.Author)
|
||||
}
|
||||
|
||||
validations, err := f.GetDataValidations(sheet)
|
||||
if err != nil {
|
||||
t.Fatalf("[%s] 读工作表 %s 的输入提示: %v", lang, sheet, err)
|
||||
}
|
||||
prompt := ""
|
||||
for _, dv := range validations {
|
||||
if dv.Sqref != "" && strings.HasPrefix(dv.Sqref, "C2") && dv.Prompt != nil {
|
||||
prompt = *dv.Prompt
|
||||
}
|
||||
}
|
||||
if !strings.Contains(prompt, "A+B") {
|
||||
t.Errorf("[%s] 单位编码列的输入提示应写明联队写法，得到 %q", lang, prompt)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 模板上的中文说明必须与导入的实际行为一致：照说明填 `A+B`，导进来就是一条报名挂两个单位、均分。
|
||||
func TestEntriesTemplateJointTeamRowImports(t *testing.T) {
|
||||
env, ids, client := recorderWithSeed(t)
|
||||
|
||||
f, _ := env.fetchTemplate(t, client, "")
|
||||
// 范围由表名承担，「项目编码 / 组别」两列留空；单位编码按模板说明写 A+B。
|
||||
appendRows(t, f, "100米跑@男子", [][]string{{
|
||||
"", "", "A+B", "联队小张", "110101199001011234", "男", "26", "301", "", "1", "registered", "",
|
||||
}})
|
||||
|
||||
status, resp := env.uploadEntries(t, client, "报名模板.xlsx", workbookBytes(t, f))
|
||||
if status != http.StatusOK || !resp.OK {
|
||||
t.Fatalf("照模板说明填的联队行应导入成功，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
if result := decodeData[entryImportResultBody](t, resp); len(result.Errors) != 0 {
|
||||
t.Fatalf("不该有报错行：%v", result.Errors)
|
||||
}
|
||||
|
||||
// 落库事实：新报名一条、两个单位各占一份（权重 1 = 均分），主单位是加号左边的 A。
|
||||
var entryID int64
|
||||
if err := env.ev.QueryRow(
|
||||
`SELECT e.id FROM entries e JOIN athletes a ON a.id = e.athlete_id
|
||||
WHERE e.event_id = ? AND a.name = '联队小张'`, ids.event).Scan(&entryID); err != nil {
|
||||
t.Fatalf("查新报名: %v", err)
|
||||
}
|
||||
var primary, shares int
|
||||
if err := env.ev.QueryRow(`SELECT team_id FROM entries WHERE id = ?`, entryID).Scan(&primary); err != nil {
|
||||
t.Fatalf("查主单位: %v", err)
|
||||
}
|
||||
if int64(primary) != ids.teamA {
|
||||
t.Errorf("主单位应是加号左边的 A（%d），得到 %d", ids.teamA, primary)
|
||||
}
|
||||
if err := env.ev.QueryRow(
|
||||
`SELECT COUNT(*) FROM entry_team_shares WHERE entry_id = ? AND points_share = 1 AND medal_share = 1`,
|
||||
entryID).Scan(&shares); err != nil {
|
||||
t.Fatalf("查份额: %v", err)
|
||||
}
|
||||
if shares != 2 {
|
||||
t.Errorf("联队报名的份额行 = %d，期望 2（两个单位各一份、均分、奖牌各整枚）", shares)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,150 @@
|
||||
package httpapi_test
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// 本文件是联队改动（devdocs/19）的「老数据零变化」硬门槛在**接口层**的一半：
|
||||
// 四种形态（普通个人 / 纯团体 / 双计 / 团体报名项双通道）走真实的导入 · 发布 · 录名次接口，
|
||||
// 再把积分榜、个人榜、报名 / 成绩 / 流水 / 通道名次四张表的原始内容拼成一份签名。
|
||||
//
|
||||
// 签名取自**联队实现之前**的代码（git archive HEAD 的修前副本上跑出来的），实现之后必须一字不差。
|
||||
//
|
||||
// 为什么特意**不含** GET /api/events/{id}/entries：那条读接口这次有意新增了 teamShares 字段
|
||||
// （联队的成员单位与权重，前端据此渲染「A+B联队」），契约变了不该算回归；
|
||||
// 它由 TestSingleUnitEntryKeepsWholeShare 单独钉住（普通报名下发一条独占份额）。
|
||||
const legacyFormsGoldenAPI = "aa6cea376734cfc5f2334551dfa3095f31543babb10e00c2318b5146a8af42d2"
|
||||
|
||||
// TestLegacyFormsAPISnapshotUnchanged 对拍四种形态的榜单与落库事实。
|
||||
func TestLegacyFormsAPISnapshotUnchanged(t *testing.T) {
|
||||
env, ids, client := recorderWithSeed(t)
|
||||
dump := legacyFormsAPIDump(t, env, client, ids)
|
||||
|
||||
// 防空转：签名里必须真的能看到四种形态的痕迹。少了这几处，对拍就成了「两份空文本相等」。
|
||||
if n := strings.Count(dump, `"totalPoints"`); n < 3 {
|
||||
t.Fatalf("积分榜签名里只有 %d 行（三个单位都该在榜上）：\n%s", n, dump)
|
||||
}
|
||||
if !strings.Contains(dump, "t:") || !strings.Contains(dump, "e:") {
|
||||
t.Fatalf("签名里应同时有「按单位录的名次」与「按报名项的名次」：\n%s", dump)
|
||||
}
|
||||
if !strings.Contains(dump, "points=") || !strings.Contains(dump, "subject_key") {
|
||||
t.Fatalf("签名里应带上流水与通道名次的落库事实：\n%s", dump)
|
||||
}
|
||||
|
||||
sum := sha256.Sum256([]byte(dump))
|
||||
got := hex.EncodeToString(sum[:])
|
||||
if got != legacyFormsGoldenAPI {
|
||||
t.Fatalf("无联队的老数据在榜单 / 流水 / 名次上变了：\n签名 = %s\n期望 = %s",
|
||||
got, legacyFormsGoldenAPI)
|
||||
}
|
||||
}
|
||||
|
||||
// legacyFormsAPIDump 造出四种形态并拼出签名文本。
|
||||
func legacyFormsAPIDump(t *testing.T, env *testEnv, client *http.Client, ids seedIDs) string {
|
||||
t.Helper()
|
||||
|
||||
// 第三个单位：颁奖牌榜上要有「没参加这个项目」的行，才能看出兜底行有没有变化。
|
||||
teamC := env.insert(t, `INSERT INTO teams (code, name, short_name, sort_order, active)
|
||||
VALUES ('C', '第三分公司', '三司', 2, 1)`)
|
||||
athC := env.insert(t, `INSERT INTO athletes (name, gender, team_id, active)
|
||||
VALUES ('王芳', '女', ?, 1)`, teamC)
|
||||
|
||||
// 形态 1 · 普通个人：seed 的 M100（individual + 个人成绩通道）。
|
||||
env.exec(t, `INSERT INTO entries (event_id, category_id, team_id, athlete_id, status)
|
||||
VALUES (?, ?, ?, ?, 'registered')`, ids.event, ids.category, teamC, athC)
|
||||
publishResults(t, env, client, ids.event, "legacy-individual",
|
||||
map[string]any{"entryId": ids.entryA, "resultValue": 11.2, "resultText": "11.2", "unit": "秒", "status": "ok"},
|
||||
map[string]any{"entryId": ids.entryB, "resultValue": 11.5, "resultText": "11.5", "unit": "秒", "status": "ok"},
|
||||
map[string]any{"entryId": envEntryID(t, env, ids.event, athC), "resultValue": 12.0, "resultText": "12.0", "unit": "秒", "status": "ok"},
|
||||
)
|
||||
|
||||
// 形态 2 · 纯团体：球类（match）+ 按单位录的团体名次。
|
||||
ballEvent, ballCategory := seedMatchEvent(t, env, ids)
|
||||
if status, resp := putTeamRanks(t, env, client, ballEvent, ballCategory, []map[string]any{
|
||||
{"teamId": ids.teamA, "rank": 1},
|
||||
{"teamId": ids.teamB, "rank": 2},
|
||||
{"teamId": teamC, "rank": 2},
|
||||
}); status != http.StatusOK {
|
||||
t.Fatalf("录团体名次应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
|
||||
// 形态 3 · 双计：个人成绩通道（不计入单位总分）+ 团体聚合通道。
|
||||
mixEvent := env.insert(t, `INSERT INTO events (sport_id, code, name, event_type, result_mode, result_type,
|
||||
compare, scored, multiplier, status)
|
||||
VALUES (?, 'MIX2', '团体引体向上', 'individual_team', 'auto', 'count', 'desc', 1, 1, 'ongoing')`, ids.sport)
|
||||
mixCategory := env.insert(t, `INSERT INTO event_categories (event_id, name, multiplier, sort_order)
|
||||
VALUES (?, '男子', 1, 0)`, mixEvent)
|
||||
env.exec(t, `INSERT INTO event_score_channels (event_id, scope, basis, profile_id, sort_order, count_to_team)
|
||||
VALUES (?, 'athlete', 'result', ?, 0, 0)`, mixEvent, profileIDByCode(t, env, "individual_top6"))
|
||||
env.exec(t, `INSERT INTO event_score_channels (event_id, scope, basis, profile_id, sort_order)
|
||||
VALUES (?, 'team', 'aggregate', ?, 1)`, mixEvent, profileIDByCode(t, env, "team_top6"))
|
||||
mixRows := make([]map[string]any, 0, 3)
|
||||
for i, athleteID := range []int64{ids.athleteA, ids.athB, athC} {
|
||||
entryID := env.insert(t, `INSERT INTO entries (event_id, category_id, team_id, athlete_id, status)
|
||||
VALUES (?, ?, ?, ?, 'registered')`, mixEvent, mixCategory, []int64{ids.teamA, ids.teamB, teamC}[i], athleteID)
|
||||
mixRows = append(mixRows, map[string]any{
|
||||
"entryId": entryID, "resultValue": 10 + i, "resultText": fmt.Sprint(10 + i), "unit": "次", "status": "ok",
|
||||
})
|
||||
}
|
||||
publishResults(t, env, client, mixEvent, "legacy-individual-team", mixRows...)
|
||||
|
||||
// 形态 4 · 团体报名项双通道：团体报名项（athlete_id 为空）+ 个人成绩通道 + 团体手工通道。
|
||||
dualEvent := env.insert(t, `INSERT INTO events (sport_id, code, name, event_type, result_mode, result_type,
|
||||
compare, scored, multiplier, status)
|
||||
VALUES (?, 'DUAL', '混合配置试验', 'team', 'auto', 'count', 'desc', 1, 1, 'ongoing')`, ids.sport)
|
||||
dualCategory := env.insert(t, `INSERT INTO event_categories (event_id, name, multiplier, sort_order)
|
||||
VALUES (?, '男子', 1, 0)`, dualEvent)
|
||||
env.exec(t, `INSERT INTO event_score_channels (event_id, scope, basis, profile_id, sort_order)
|
||||
VALUES (?, 'athlete', 'result', ?, 0)`, dualEvent, profileIDByCode(t, env, "individual_top6"))
|
||||
env.exec(t, `INSERT INTO event_score_channels (event_id, scope, basis, profile_id, sort_order)
|
||||
VALUES (?, 'team', 'manual', ?, 1)`, dualEvent, profileIDByCode(t, env, "team_top6"))
|
||||
dualRows := make([]map[string]any, 0, 3)
|
||||
for i, teamID := range []int64{ids.teamA, ids.teamB, teamC} {
|
||||
entryID := env.insert(t, `INSERT INTO entries (event_id, category_id, team_id, athlete_id, status)
|
||||
VALUES (?, ?, ?, NULL, 'registered')`, dualEvent, dualCategory, teamID)
|
||||
dualRows = append(dualRows, map[string]any{
|
||||
"entryId": entryID, "resultValue": 90 - 10*i, "resultText": fmt.Sprint(90 - 10*i), "unit": "次", "status": "ok",
|
||||
})
|
||||
}
|
||||
publishResults(t, env, client, dualEvent, "legacy-dual", dualRows...)
|
||||
// 团体名次按单位录（覆盖值优先于报名项自己的名次）：这一支产出的名次没有报名项，
|
||||
// subject_key 是「单位」，正是这次改动碰过的地方。
|
||||
if status, resp := putTeamRanks(t, env, client, dualEvent, dualCategory, []map[string]any{
|
||||
{"teamId": ids.teamA, "rank": 2},
|
||||
{"teamId": ids.teamB, "rank": 1},
|
||||
{"teamId": teamC, "rank": 3},
|
||||
}); status != http.StatusOK {
|
||||
t.Fatalf("录团体名次应 200，得到 %d %+v", status, resp.Error)
|
||||
}
|
||||
|
||||
return strings.Join([]string{
|
||||
rawData(t, env, client, "/api/standings"),
|
||||
rawData(t, env, client, "/api/standings/athletes"),
|
||||
tableDump(t, env, `SELECT id, event_id, category_id, team_id, COALESCE(athlete_id, 0) AS athlete_id, status
|
||||
FROM entries ORDER BY id`),
|
||||
tableDump(t, env, `SELECT id, event_id, entry_id, COALESCE(rank, 0) AS rank, COALESCE(result_value, 0) AS value,
|
||||
status, state FROM results ORDER BY id`),
|
||||
tableDump(t, env, `SELECT id, team_id, COALESCE(athlete_id, 0) AS athlete_id, COALESCE(event_id, 0) AS event_id,
|
||||
COALESCE(entry_id, 0) AS entry_id, source_type, source_id, points, count_to_team, voided
|
||||
FROM score_ledger ORDER BY id`),
|
||||
tableDump(t, env, `SELECT id, event_id, category_id, channel_id, basis, scope, subject_key,
|
||||
COALESCE(entry_id, 0) AS entry_id, COALESCE(team_id, 0) AS team_id, rank, points
|
||||
FROM channel_ranks ORDER BY id`),
|
||||
}, "\n---\n") + "\n"
|
||||
}
|
||||
|
||||
// envEntryID 取某小项里某运动员的报名项 id。
|
||||
func envEntryID(t *testing.T, env *testEnv, eventID, athleteID int64) int64 {
|
||||
t.Helper()
|
||||
var id int64
|
||||
if err := env.ev.QueryRow(
|
||||
`SELECT id FROM entries WHERE event_id = ? AND athlete_id = ?`, eventID, athleteID).Scan(&id); err != nil {
|
||||
t.Fatalf("读报名项: %v", err)
|
||||
}
|
||||
return id
|
||||
}
|
||||
@@ -45,6 +45,14 @@ type entryHeatPayload struct {
|
||||
RequestID string `json:"requestId"`
|
||||
}
|
||||
|
||||
// entryTeamSharesPayload 是 PUT /api/entries/{id}/team-shares 的请求体：整组替换一条报名的份额。
|
||||
// 不传重量字段（weight 缺省 1）就是均分；medal 缺省 true = 这枚奖牌整枚记给该单位。
|
||||
// 必须包含主单位（entries.team_id），且每个单位只能出现一次——校验见 validateEntryShares。
|
||||
type entryTeamSharesPayload struct {
|
||||
TeamShares []entryTeamShareDTO `json:"teamShares"`
|
||||
RequestID string `json:"requestId"`
|
||||
}
|
||||
|
||||
// entryBatchPayload 是报名项批量操作的请求体：
|
||||
// action 决定语义（scratch 退赛可恢复 / restore 恢复 / remove 物理移出报名），
|
||||
// ids 是勾选的报名项（重复会自动去重），reason 可选、只进审计便于事后对账。
|
||||
|
||||
@@ -832,7 +832,18 @@ func (s *server) listEntries(ctx context.Context, eventID int64) ([]entryDTO, er
|
||||
}
|
||||
out = append(out, e)
|
||||
}
|
||||
return out, rows.Err()
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// 份额单独查一次再挂上：一个报名可能有多条（联队），join 进上面那条 SQL 会把报名行乘开。
|
||||
shares, err := s.loadEntrySharesDTOs(ctx, s.ev, eventID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for i := range out {
|
||||
out[i].TeamShares = entrySharesOf(shares[out[i].ID], out[i].TeamID, out[i].TeamCode, out[i].TeamName)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// listEntriesWithResults 返回报名项及其成绩（无成绩时 result=null）。
|
||||
|
||||
@@ -674,11 +674,19 @@ func (s *server) upsertImportedEntry(ctx context.Context, in entryDTO) (entryImp
|
||||
if err != nil {
|
||||
return entryImportOutcome{}, err
|
||||
}
|
||||
if _, err := s.ev.ExecContext(ctx,
|
||||
res, err := s.ev.ExecContext(ctx,
|
||||
`INSERT INTO entries (event_id, category_id, team_id, athlete_id, member_names, bib, seed, heat, status)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||||
in.EventID, in.CategoryID, in.TeamID, nullI64(in.AthleteID), marshalNames(in.MemberNames),
|
||||
nullStr(in.Bib), nullStr(in.Seed), nullI64(in.Heat), status); err != nil {
|
||||
nullStr(in.Bib), nullStr(in.Seed), nullI64(in.Heat), status)
|
||||
if err != nil {
|
||||
return entryImportOutcome{}, err
|
||||
}
|
||||
newID, err := res.LastInsertId()
|
||||
if err != nil {
|
||||
return entryImportOutcome{}, internal(err)
|
||||
}
|
||||
if err := replaceEntryShares(ctx, s.ev, newID, in.TeamID, in.TeamShares); err != nil {
|
||||
return entryImportOutcome{}, err
|
||||
}
|
||||
outcome := entryImportOutcome{Created: true, EventID: in.EventID, CategoryID: in.CategoryID}
|
||||
@@ -705,6 +713,11 @@ func (s *server) upsertImportedEntry(ctx context.Context, in entryDTO) (entryImp
|
||||
status, existing); err != nil {
|
||||
return entryImportOutcome{}, err
|
||||
}
|
||||
// 份额整组重写：同一行重传要幂等，改了写法（联队改回单单位、换成员）也要跟着变，
|
||||
// 只增不改会把上一次的配置一直用下去（见 replaceEntryShares）。
|
||||
if err := replaceEntryShares(ctx, s.ev, existing, in.TeamID, in.TeamShares); err != nil {
|
||||
return entryImportOutcome{}, err
|
||||
}
|
||||
return entryImportOutcome{
|
||||
EventID: in.EventID,
|
||||
CategoryID: in.CategoryID,
|
||||
|
||||
@@ -619,17 +619,26 @@ func (s *server) buildRanked(ctx context.Context, q queryer) ([]domain.RankedRes
|
||||
v := value.Float64
|
||||
rr.ResultValue = &v
|
||||
}
|
||||
// 归属份额沿用「主单位独占 100%」：team_id 为空（理论上不会）时不造份额，
|
||||
// 免得给 0 号单位凭空记牌，与 domain 的 wholeShare 一致。
|
||||
if rr.TeamID != 0 {
|
||||
rr.Shares = []domain.TeamShare{{TeamID: rr.TeamID, Weight: 1}}
|
||||
}
|
||||
rr.AwardMedals = awardMedals != 0
|
||||
rr.CountToMedals = countToMedals != 0
|
||||
rr.CountToTeamMedals = countToTeamMedals != 0
|
||||
out = append(out, rr)
|
||||
}
|
||||
return out, rows.Err()
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// 归属份额按报名项的配置补：channel_ranks 只存名次与主体（entry_id 有外键、可回查），
|
||||
// 份额是报名项上的配置，引擎与榜单两边都必须从同一处读——
|
||||
// 没有报名项的名次（聚合 / 团体手工）与没配份额的老数据都退回「主单位独占 100%」，
|
||||
// 与 domain.ResolveShares 同一口径（老数据因此一分一牌都不变）。
|
||||
shares, err := loadEntryTeamSharesQ(ctx, q, 0)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for i := range out {
|
||||
out[i].Shares = domain.ResolveShares(shares[out[i].EntryID], out[i].TeamID)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// breakdownRankExpr 取一条单位流水的名次（devdocs 17 §11.3）：优先按流水对应的通道与主体
|
||||
|
||||
@@ -236,7 +236,18 @@ func loadEntriesQ(ctx context.Context, q queryer, eventID, categoryID int64) ([]
|
||||
e.MemberNames = parseNames(memberNames)
|
||||
out = append(out, e)
|
||||
}
|
||||
return out, rows.Err()
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// 联队份额随报名一起进引擎：引擎不看库，取分只认 Entry.TeamShares。
|
||||
shares, err := loadEntryTeamSharesQ(ctx, q, eventID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for i := range out {
|
||||
out[i].TeamShares = shares[out[i].ID]
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func loadResultsQ(ctx context.Context, q queryer, eventID, categoryID int64) ([]domain.Result, error) {
|
||||
@@ -503,7 +514,8 @@ func hasSubjectChannel(ctx context.Context, tx *sql.Tx, eventID int64) (bool, er
|
||||
// 结算范围与流水一致：categoryID > 0 只重建该组别，否则重建整个小项。
|
||||
// SubjectKey 是 (通道, 组别, 主体) 的唯一键，聚合与团体手工名次没有报名项，靠它落库。
|
||||
// AwardMedals / CountToMedals / CountToTeamMedals 是读取侧 join events / event_score_channels
|
||||
// 得到的，不落这张表；shares 不进表（当前只有「主单位独占 100%」一种口径，读取侧按 team_id 重建）。
|
||||
// 得到的，不落这张表；shares 同样不进表——读取侧按 entry_id 回查报名份额（entry_team_shares），
|
||||
// 回查不到（没有报名项的名次、没配份额的老数据）与引擎一样退回「主单位独占 100%」。
|
||||
func writeChannelRanksTx(ctx context.Context, tx *sql.Tx, score domain.EventScore, eventID, categoryID int64) error {
|
||||
if categoryID > 0 {
|
||||
if _, err := tx.ExecContext(ctx,
|
||||
|
||||
@@ -276,6 +276,9 @@ func (s *server) routes(mux *http.ServeMux) {
|
||||
// 报名项批量操作：退赛（scratched，可恢复）/ 恢复 / 移出报名（物理删除，不可恢复）。
|
||||
// 权限与发布同档（recorder），不新增角色；跨小项混选允许，服务端按 (小项, 组别) 分组重算。
|
||||
mux.HandleFunc("POST /api/entries/batch", s.write(auth.RoleRecorder, s.batchEntriesHandler))
|
||||
// 联队份额（devdocs/19）：改一条报名的成员单位与权重，改完当场重算并推榜。
|
||||
// 与其它报名写入同档权限（recorder）：它改的是报名，权限不该比报名导入更宽。
|
||||
mux.HandleFunc("PUT /api/entries/{id}/team-shares", s.write(auth.RoleRecorder, s.updateEntryTeamSharesHandler))
|
||||
|
||||
// 成绩
|
||||
mux.HandleFunc("GET /api/results", s.public(s.listResultsHandler))
|
||||
|
||||
@@ -330,15 +330,64 @@ func loadRanked(ctx context.Context, tx *sql.Tx) ([]domain.RankedResult, error)
|
||||
v := value.Float64
|
||||
rr.ResultValue = &v
|
||||
}
|
||||
// 与 REST 同口径：份额只有「主单位独占 100%」一种，team_id 为空时不造份额。
|
||||
if rr.TeamID != 0 {
|
||||
rr.Shares = []domain.TeamShare{{TeamID: rr.TeamID, Weight: 1}}
|
||||
}
|
||||
rr.AwardMedals = awardMedals != 0
|
||||
rr.CountToMedals = countToMedals != 0
|
||||
rr.CountToTeamMedals = countToTeamMedals != 0
|
||||
out = append(out, rr)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// 与 REST 的 buildRanked、导出的 loadRanked 同口径：联队份额按报名项配置补，
|
||||
// 没有报名项的名次与没配份额的老数据退回「主单位独占 100%」。
|
||||
// 大屏的奖牌榜读的就是这里——少补这一趟，联队的名次在大屏上只记给主单位。
|
||||
shares, err := loadEntryTeamShares(ctx, tx)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for i := range out {
|
||||
out[i].Shares = domain.ResolveShares(shares[out[i].EntryID], out[i].TeamID)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// loadEntryTeamShares 读全部报名的份额（联队配置），按 entry_id 归组。
|
||||
//
|
||||
// 表不在（库还没跑到 0024）时返回空：没有份额表就没有联队配置，主单位独占 100% 正是老库
|
||||
// 本来就该得到的结果，不是容错降级（见 httpapi.entryTeamSharesReady）。
|
||||
func loadEntryTeamShares(ctx context.Context, tx *sql.Tx) (map[int64][]domain.TeamShare, error) {
|
||||
var n int
|
||||
if err := tx.QueryRowContext(ctx,
|
||||
`SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = 'entry_team_shares'`).Scan(&n); err != nil {
|
||||
return nil, fmt.Errorf("查询报名份额表: %w", err)
|
||||
}
|
||||
if n == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
rows, err := tx.QueryContext(ctx, `SELECT entry_id, team_id, points_share, medal_share
|
||||
FROM entry_team_shares
|
||||
ORDER BY entry_id, sort_order, team_id`)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("读取报名份额: %w", err)
|
||||
}
|
||||
defer func() { _ = rows.Close() }()
|
||||
|
||||
out := make(map[int64][]domain.TeamShare)
|
||||
for rows.Next() {
|
||||
var (
|
||||
entryID int64
|
||||
s domain.TeamShare
|
||||
medal int
|
||||
)
|
||||
if err := rows.Scan(&entryID, &s.TeamID, &s.Weight, &medal); err != nil {
|
||||
return nil, fmt.Errorf("扫描报名份额: %w", err)
|
||||
}
|
||||
if medal == 0 {
|
||||
excluded := false
|
||||
s.Medal = &excluded
|
||||
}
|
||||
out[entryID] = append(out[entryID], s)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
package realtime
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// 大屏（WS 快照）是联队奖牌的第三条读路径（另有 REST 与 xlsx 导出）。
|
||||
// 它读 channel_ranks 之后要按报名项的份额补归属，少了这一步，联队拿到的金牌在大屏上
|
||||
// 只会记给主单位，B 单位明明一起拿了金牌却榜上无名。
|
||||
//
|
||||
// 这里造一条「联队报名 + 团体名次」的最小现场：报名挂在 A 头上、份额是 A+B，
|
||||
// 名次 1（金牌）落在这条报名上，断言两个单位各记 1 枚。
|
||||
func TestSnapshotJointTeamMedalsGoToEveryMember(t *testing.T) {
|
||||
env := newTestEnv(t)
|
||||
db := env.db
|
||||
|
||||
teamA := insertTeam(t, db, "A", "第一分公司", "一司")
|
||||
teamB := insertTeam(t, db, "B", "第二分公司", "二司")
|
||||
eventID := insertEvent(t, db, "BALL", "篮球")
|
||||
categoryID := insertCategory(t, db, eventID, "男子")
|
||||
entryID := insertEntry(t, db, eventID, categoryID, teamA, 0)
|
||||
channelID := insertChannel(t, db, eventID, "team")
|
||||
mustExec(t, db, `INSERT INTO channel_ranks (event_id, category_id, channel_id, basis, scope, subject_key,
|
||||
entry_id, team_id, rank, points, status)
|
||||
VALUES (?, ?, ?, 'manual', 'team', ?, ?, ?, 1, 0, 'ok')`,
|
||||
eventID, categoryID, channelID, fmt.Sprintf("e:%d", entryID), entryID, teamA)
|
||||
// 联队份额：A、B 均分、奖牌各记整枚（写侧就是这么落的，见 entry_team_shares 的迁移与 httpapi）。
|
||||
mustExec(t, db, `INSERT INTO entry_team_shares (entry_id, team_id, points_share, medal_share, sort_order)
|
||||
VALUES (?, ?, 1, 1, 0), (?, ?, 1, 1, 1)`, entryID, teamA, entryID, teamB)
|
||||
|
||||
snap, err := env.hub.Snapshot(context.Background())
|
||||
if err != nil {
|
||||
t.Fatalf("构建快照: %v", err)
|
||||
}
|
||||
gold := make(map[int64]int, len(snap.Standings))
|
||||
for _, row := range snap.Standings {
|
||||
gold[row.TeamID] = row.Gold
|
||||
}
|
||||
if gold[teamA] != 1 {
|
||||
t.Fatalf("主单位 A 应记 1 枚金牌，得到 %d（完整：%+v）", gold[teamA], snap.Standings)
|
||||
}
|
||||
if gold[teamB] != 1 {
|
||||
t.Fatalf("成员单位 B 也应记 1 枚金牌（不是 0.5 枚、也不是 0 枚），得到 %d（完整：%+v）",
|
||||
gold[teamB], snap.Standings)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user