feat(0.5.1): 业务逻辑审查 9 条 P0 全修 + 自绘安装器 + 现场反馈四项

## 算分正确性(6 份只读审查 → 收敛成 5 个病根,均先复现失败再修)
- 「人工名次」与「自动名次回写」互斥:原来同一份成绩**发布两次分数不同**
  (团体报名项 dual 通道 10/8/6 → 25/18/14),现在连发多次逐字节一致
- 删小项时在同一事务作废旧流水并推榜:原来分数**永久残留**在总榜、任何重算都打不到
- 规则包导入整体事务化:原来中途失败会清空名次表且补不回(奖牌全丢);
  另加守卫「compare=none 的小项不得配 basis=result/aggregate」
- 末位归零只抹真正落在末位的那一档:原来跨末位的并列组会被整组抹 0
  (7 人三人并列第 5 时第 5、6 名的分也一起没了)
- 模板「分值表档位超出录取名次」现在拒绝保存:原来静默截断成 0 分

## 现场反馈(主人实测报的)
- 已发布成绩可改:行内「修改本条」+ 成绩格/状态格可点(退回草稿→改→重新发布本组),
  与「作废」语义分开;取消路径不产生任何副作用
- 单位积分明细补「运动员 / 来源」列,并显示「已修订 ×N(时间·原因)」:
  管理端、大屏覆盖层、xlsx 备注列三处同源
- 单位奖牌榜改为按奖牌独立排名(金→银→铜→单位编码),与积分榜解耦
- 历史孤儿积分流水清理(迁移 0022,只动 result/record_bonus,人工调整分不受影响)

## 新功能
- 团体项目聚合口径二选一:平均(默认)/ 总和(迁移 0023,通道编辑器可切)

## 安装器
- 自绘五页安装界面:无边框、自绘标题栏、DPI 自适应(4K@200% 实测)、
  安装/卸载逻辑复用 electron-builder 宏不变;默认「为所有用户安装」并自动放行防火墙 19540
- 构建期校验:安装器素材里的版本号必须与 VERSION 一致,否则构建失败

自检:服务端 14 包 ×2 / 前端 vue-tsc + build + 742 例 ×2 / Console 20 文件 + 68 例 ×2,全绿。
端到端对拍:修前 vs 修后,纯团体 / 双计 / 普通个人三形态**逐字节一致**,仅出 bug 的双通道形态按要求改变。
This commit is contained in:
AskaEth committed 2026-09-13 15:20:18 +08:00
1 parent 78b14efaa9
commit 877ff15823
181 files changed
+8747 -371

No files matched your search

@@ -0,0 +1,27 @@
-- 清理升级前留下的「孤儿流水」:删掉一个「只有名次、没有报名项」的小项时
-- (球类那种形态,名次直接按单位录进 channel_manual_ranks),名下的成绩流水
-- 被 score_ledger.event_id 的 ON DELETE SET NULL 置空,而 voided 仍然是 0 ——
-- 分数留在榜上,此后任何按 event_id 的重算都再也打不到这些行,只能改库。
--
-- 写侧已经补上了「删小项时在同一事务里作废」(httpapi/repo_events.go 的 deleteEvent),
-- 但**升级前已经产生**的那批不会被自动清掉,现场确认删过带分的小项。这条迁移就是那一次性清理。
--
-- 只作废 source_type IN ('result', 'record_bonus'):
-- - 这两类流水全部由计分引擎产出,引擎一直把 EventID 写进库(domain/scoring.go),
-- 所以「event_id 为空」只可能来自小项被删后的置空,即孤儿;
-- - 人工调整(source_type = 'adjustment')**合法地**就是 event_id 为 NULL
-- (写入口 httpapi/repo_misc.go 的 createAdjustment,见 domain/ledger.go 的说明),
-- 一刀切会把合法的调整分一起吞掉。
--
-- 作废而不是删除:流水行要留着当审计痕迹(voided_at + void_reason 说明「谁也没做,是升级清理」)。
-- voided_by 刻意留 NULL:这次清理没有人操作,编一个操作人就是假账。
--
-- 幂等:条件里的 voided = 0 让重复执行只剩空更新;迁移本身还由 schema_migrations 记账只放行一次,
-- 所以「重复启动 / 手工重放这条 SQL」都不会重复作废,也不会覆盖已有流水的作废时间与理由。
UPDATE score_ledger
SET voided = 1,
voided_at = datetime('now'),
void_reason = 'event_id 已失效(历史孤儿)'
WHERE voided = 0
AND event_id IS NULL
AND source_type IN ('result', 'record_bonus');
@@ -0,0 +1,13 @@
-- 聚合通道(basis=aggregate)的汇总口径。
--
-- 背景:团体分要能现场在「按成员平均」与「按成员总和」之间切。此前只有平均值一种口径
-- (平均值内部的分母口径是 0017 加的 events.avg_mode),这里把「汇总方式」按通道存下来。
--
-- 只加列、不动既有数据行:老通道一律取默认值 'avg',升级前后榜单一分不差。
-- 取值:
-- avg:团体成绩 = 该主体成员成绩的平均值(缺省,与升级前行为一致);
-- sum:团体成绩 = 该主体成员成绩的总和。
-- 汇总口径与 avg_mode 是两个维度:sum 下 avg_mode 只决定「一个有效成绩都没有的单位
-- 算不算 0 分参与排名」(valid 不参与 / all 参与),见 domain/scoring.go 的 scoreByAggregate。
ALTER TABLE event_score_channels ADD COLUMN aggregate_mode TEXT NOT NULL DEFAULT 'avg'
CHECK (aggregate_mode IN ('avg', 'sum'));
@@ -0,0 +1,262 @@
package event
import (
"context"
"database/sql"
"io"
"io/fs"
"log/slog"
"reflect"
"testing"
"git.yeij.top/AskaEth/Scoreboard/server/internal/realtime"
"git.yeij.top/AskaEth/Scoreboard/server/internal/store"
"git.yeij.top/AskaEth/Scoreboard/server/migrations"
)
// 孤儿流水的统一口径:计分引擎产出的成绩分与破纪录加分,但 event_id 已被置空。
const orphanLedgerCond = `voided = 0 AND event_id IS NULL AND source_type IN ('result', 'record_bonus')`
// 0022 一次性清理升级前留下的孤儿流水:删掉「只有名次、没有报名项」的小项时,
// score_ledger.event_id 被 ON DELETE SET NULL 置空而 voided 仍是 0,分数留在榜上、
// 之后任何按 event_id 的重算都打不到这些行。写侧(deleteEvent)已补上作废,这条迁移管历史那批。
//
// 三条底线:
// - 只清 result / record_bonus。人工调整合法地就是 event_id 为 NULL,一刀切会吞掉合法调整分;
// - 作废而不是删除,留 voided_at + void_reason 当审计痕迹,且不能覆盖已有的作废理由与时间;
// - 幂等:连跑两次,榜与每一行都必须一模一样。
func TestMigration0022VoidsHistoricalOrphanLedger(t *testing.T) {
db := openEventDB(t)
applyBefore(t, db, "0022") // 回到「升级前」:库结构到 0021 为止,0022 还没跑过
// 造现场:E1 是还在的小项;E2 是那种「只有团体名次、没有报名项」的小项,被删掉过。
stmts := []string{
`INSERT INTO teams(code, name) VALUES ('T1', '第一分公司')`,
`INSERT INTO sports(code, name) VALUES ('SP1', '田径')`,
`INSERT INTO events(sport_id, code, name, event_type, result_mode, result_type, compare, status)
VALUES (1, 'E1', '100米跑', 'individual', 'auto', 'time', 'asc', 'published')`,
`INSERT INTO events(sport_id, code, name, event_type, result_mode, result_type, compare, status)
VALUES (1, 'E2', '篮球', 'team', 'manual', 'none', 'none', 'published')`,
// 行 1:健康流水,挂在还在的 E1 上。
`INSERT INTO score_ledger(team_id, event_id, source_type, source_id, points)
VALUES (1, 1, 'result', 1, 10)`,
// 行 2、3:升级前的孤儿——删 E2 时 event_id 被置空、voided 还是 0(这条迁移要清的就是它们)。
`INSERT INTO score_ledger(team_id, event_id, source_type, source_id, points)
VALUES (1, 2, 'result', 2, 4)`,
`INSERT INTO score_ledger(team_id, event_id, source_type, source_id, points)
VALUES (1, 2, 'record_bonus', 2, 2)`,
// 行 4:合法的人工调整,event_id 本来就允许为空,必须原样保留(防误伤的关键一条)。
`INSERT INTO score_ledger(team_id, source_type, source_id, points)
VALUES (1, 'adjustment', 9, 7)`,
// 行 5:升级前已经被正确作废过的孤儿,理由/时间都不能被这次清理改写。
`INSERT INTO score_ledger(team_id, event_id, source_type, source_id, points, voided, voided_at, void_reason)
VALUES (1, 2, 'result', 3, 1, 1, '2026-09-01 08:00:00', '小项删除,本小项积分流水一并作废')`,
}
for _, s := range stmts {
if _, err := db.Exec(s); err != nil {
t.Fatalf("造升级前数据 %q: %v", s, err)
}
}
// 旧删除路径:老 deleteEvent 只删小项本身(子表先删),流水只被外键置空。
if _, err := db.Exec(`DELETE FROM events WHERE id = 2`); err != nil {
t.Fatalf("按旧路径删除小项 E2: %v", err)
}
// 升级前:两条孤儿还活着,且分真的挂在榜上(这就是现场看到的错榜)。
if got := queryInt(t, db, `SELECT count(*) FROM score_ledger WHERE `+orphanLedgerCond); got != 2 {
t.Fatalf("升级前应有 2 条孤儿流水,得到 %d", got)
}
if got := boardPoints(t, db, 1); got != 23 {
t.Fatalf("升级前孤儿分应还在榜上(10+4+2+7=23),得到 %v", got)
}
// 走真实升级路径(main.go 打开旧库后补跑的就是它),跑两次验幂等。
if err := store.MigrateEvent(db); err != nil {
t.Fatalf("第 1 次迁移: %v", err)
}
afterFirst := dumpLedger(t, db)
if err := store.MigrateEvent(db); err != nil {
t.Fatalf("第 2 次迁移: %v", err)
}
if got := dumpLedger(t, db); !reflect.DeepEqual(got, afterFirst) {
t.Errorf("重复迁移改动了流水:\n第一次 %+v\n第二次 %+v", afterFirst, got)
}
if got, want := countRows(t, db, "schema_migrations"), migrationCount(t); got != want {
t.Errorf("迁移登记数 = %d,期望 %d", got, want)
}
// 幂等还要经得起「迁移被重放」:store.migrate 的注释写明,schema_migrations 少一行
// (手工删行 / 从别处拷来的库)就会把跑过的迁移再跑一遍。这里直接重放这条 SQL 的正文,
// 结果必须与第一次一致——不改动分值,也不重写已作废流水的作废时间。
if _, err := db.Exec(readMigration(t, "0022")); err != nil {
t.Fatalf("重放 0022: %v", err)
}
if got := dumpLedger(t, db); !reflect.DeepEqual(got, afterFirst) {
t.Errorf("重放 0022 改动了流水:\n重放前 %+v\n重放后 %+v", afterFirst, got)
}
// 作废是作废、不是删除:五行流水一行不少。
if got := countRows(t, db, "score_ledger"); got != 5 {
t.Fatalf("升级后流水行数 = %d,期望 5(作废要留审计痕迹,不能删行)", got)
}
if got := queryInt(t, db, `SELECT count(*) FROM score_ledger WHERE `+orphanLedgerCond); got != 0 {
t.Errorf("升级后仍剩 %d 条存活孤儿流水", got)
}
// 工单①:行 2、3 两条孤儿被作废,且写明时间与原因;voided_by 留空表示「不是人做的,是升级清理」。
for _, id := range []int64{2, 3} {
var (
voided int
voidedBy sql.NullInt64
voidedAt sql.NullString
voidReason sql.NullString
)
if err := db.QueryRow(`SELECT voided, voided_by, voided_at, void_reason FROM score_ledger WHERE id = ?`, id).
Scan(&voided, &voidedBy, &voidedAt, &voidReason); err != nil {
t.Fatalf("读流水 %d: %v", id, err)
}
if voided != 1 {
t.Errorf("孤儿流水 %d 应被作废,voided = %d", id, voided)
}
if !voidedAt.Valid || voidedAt.String == "" {
t.Errorf("孤儿流水 %d 缺少作废时间: %+v", id, voidedAt)
}
if !voidReason.Valid || voidReason.String != "event_id 已失效(历史孤儿)" {
t.Errorf("孤儿流水 %d 的作废原因不对: %+v", id, voidReason)
}
if voidedBy.Valid {
t.Errorf("孤儿流水 %d 的 voided_by 应留空(没有操作人),得到 %d", id, voidedBy.Int64)
}
}
// 工单②:合法调整分原样保留——没被作废、没有理由、分值不变。
var (
points float64
voided int
voidedAt sql.NullString
voidReason sql.NullString
)
if err := db.QueryRow(`SELECT points, voided, voided_at, void_reason FROM score_ledger WHERE id = 4`).
Scan(&points, &voided, &voidedAt, &voidReason); err != nil {
t.Fatalf("读调整流水: %v", err)
}
if points != 7 || voided != 0 || voidedAt.Valid || voidReason.Valid {
t.Errorf("人工调整被误伤: points=%v voided=%d voided_at=%+v void_reason=%+v", points, voided, voidedAt, voidReason)
}
// 行 1:健康流水(小项还在)不受影响。
if got := queryInt(t, db, `SELECT voided FROM score_ledger WHERE id = 1`); got != 0 {
t.Errorf("挂在还活着的小项上的流水被误作废: voided = %d", got)
}
// 行 5:早已作废的那条保留自己的理由与时间,不被这次清理重写。
var (
oldAt sql.NullString
oldReason sql.NullString
)
if err := db.QueryRow(`SELECT voided_at, void_reason FROM score_ledger WHERE id = 5`).Scan(&oldAt, &oldReason); err != nil {
t.Fatalf("读老作废流水: %v", err)
}
if !oldAt.Valid || oldAt.String != "2026-09-01 08:00:00" ||
!oldReason.Valid || oldReason.String != "小项删除,本小项积分流水一并作废" {
t.Errorf("老作废痕迹被改写: voided_at=%+v void_reason=%+v", oldAt, oldReason)
}
// 榜单:孤儿分(4 与 2)消失,只留下健康分 10 与合法调整 7。连跑两次后仍是 17。
if got := boardPoints(t, db, 1); got != 17 {
t.Errorf("升级后单位总分应只剩 10+7=17,得到 %v", got)
}
fkRows, err := db.Query(`PRAGMA foreign_key_check`)
if err != nil {
t.Fatalf("外键检查: %v", err)
}
defer func() { _ = fkRows.Close() }()
if fkRows.Next() {
t.Error("清理后存在外键悬挂")
}
}
// readMigration 取出嵌入的赛事库迁移正文(按文件名前缀找),
// 用于在测试里直接重放某一条迁移,验证 SQL 自身的幂等。
func readMigration(t *testing.T, prefix string) string {
t.Helper()
fsys, err := fs.Sub(migrations.EventFS, "event")
if err != nil {
t.Fatalf("定位迁移目录: %v", err)
}
names, err := fs.Glob(fsys, prefix+"*.sql")
if err != nil {
t.Fatalf("列出迁移: %v", err)
}
if len(names) != 1 {
t.Fatalf("迁移 %s*.sql 命中 %d 个文件: %v", prefix, len(names), names)
}
body, err := fs.ReadFile(fsys, names[0])
if err != nil {
t.Fatalf("读取迁移 %s: %v", names[0], err)
}
return string(body)
}
// boardPoints 走真实的大屏读路径(实时快照)取某单位的总分:
// 「孤儿分是否还挂在榜上」要按大屏看到的口径判定,而不是数 score_ledger 的行数。
func boardPoints(t *testing.T, db *sql.DB, teamID int64) float64 {
t.Helper()
hub := realtime.NewHub(db, slog.New(slog.NewTextHandler(io.Discard, nil)))
defer func() { _ = hub.Close() }()
snap, err := hub.Snapshot(context.Background())
if err != nil {
t.Fatalf("取榜单快照: %v", err)
}
for _, row := range snap.Standings {
if row.TeamID == teamID {
return row.TotalPoints
}
}
t.Fatalf("榜单里没有单位 %d: %+v", teamID, snap.Standings)
return 0
}
// ledgerRow 是流水行的完整快照,用于比对「连跑两次」有没有改动任何一格。
type ledgerRow struct {
id int64
points float64
voided int
voidedBy sql.NullInt64
voidedAt sql.NullString
voidReason sql.NullString
}
func dumpLedger(t *testing.T, db *sql.DB) []ledgerRow {
t.Helper()
rows, err := db.Query(`SELECT id, points, voided, voided_by, voided_at, void_reason
FROM score_ledger ORDER BY id`)
if err != nil {
t.Fatalf("读流水: %v", err)
}
defer func() { _ = rows.Close() }()
var out []ledgerRow
for rows.Next() {
var r ledgerRow
if err := rows.Scan(&r.id, &r.points, &r.voided, &r.voidedBy, &r.voidedAt, &r.voidReason); err != nil {
t.Fatalf("解析流水: %v", err)
}
out = append(out, r)
}
if err := rows.Err(); err != nil {
t.Fatalf("遍历流水: %v", err)
}
return out
}
func queryInt(t *testing.T, db *sql.DB, query string, args ...any) int {
t.Helper()
var n int
if err := db.QueryRow(query, args...).Scan(&n); err != nil {
t.Fatalf("查询 %q: %v", query, err)
}
return n
}
@@ -0,0 +1,99 @@
package event
import (
"database/sql"
"strings"
"testing"
"git.yeij.top/AskaEth/Scoreboard/server/internal/store"
)
// 0023:聚合通道(basis=aggregate)的汇总口径 aggregate_mode。
//
// 三条底线:
// - 老库升级后每一行都拿到默认值 avg —— 升级前只有「按成员平均」一种口径,榜单必须一分不差;
// - 其它列与行数一行不动(这是纯加列迁移);
// - 取值只允许 avg / sum,拼错的取值在写侧就被 CHECK 挡下;
// - 幂等:连跑两次不报错、不重复登记。
func TestMigration0023ChannelAggregateMode(t *testing.T) {
db := openEventDB(t)
applyBefore(t, db, "0023") // 回到「升级前」:库结构到 0022 为止
var teamProfile int64
if err := db.QueryRow(`SELECT id FROM scoring_profiles WHERE code = 'team_top6'`).Scan(&teamProfile); err != nil {
t.Fatalf("读取团体积分模板: %v", err)
}
stmts := []string{
`INSERT INTO teams(code, name) VALUES ('T1', '第一分公司')`,
`INSERT INTO sports(code, name) VALUES ('SP1', '田径')`,
`INSERT INTO events(sport_id, code, name, event_type, result_mode, result_type, compare, scored, multiplier, status)
VALUES (1, 'TEAM_PULLUP', '团体引体向上', 'individual_team', 'auto', 'count', 'desc', 1, 2, 'published')`,
}
for _, s := range stmts {
if _, err := db.Exec(s); err != nil {
t.Fatalf("造老库数据 %q: %v", s, err)
}
}
if _, err := db.Exec(`INSERT INTO event_score_channels(event_id, scope, basis, profile_id, sort_order, count_to_team)
VALUES (1, 'team', 'aggregate', ?, 1, 1)`, teamProfile); err != nil {
t.Fatalf("造老库通道: %v", err)
}
// 升级前:这一列还不该存在。
var probe sql.NullString
if err := db.QueryRow(`SELECT aggregate_mode FROM event_score_channels`).Scan(&probe); err == nil {
t.Fatal("升级前不应存在 aggregate_mode 列")
} else if !strings.Contains(err.Error(), "aggregate_mode") {
t.Fatalf("查询报错应点明缺列 aggregate_mode,实际 %v", err)
}
if err := store.MigrateEvent(db); err != nil {
t.Fatalf("升级赛事库: %v", err)
}
// 老行取默认值 avg,其它列原样。
var (
scope, basis, mode string
countToTeam int
sortOrder int
)
if err := db.QueryRow(`SELECT scope, basis, aggregate_mode, count_to_team, sort_order
FROM event_score_channels WHERE event_id = 1`).
Scan(&scope, &basis, &mode, &countToTeam, &sortOrder); err != nil {
t.Fatalf("读取升级后的通道: %v", err)
}
if scope != "team" || basis != "aggregate" || countToTeam != 1 || sortOrder != 1 {
t.Fatalf("升级不应改动既有列:scope=%q basis=%q count_to_team=%d sort_order=%d", scope, basis, countToTeam, sortOrder)
}
if mode != "avg" {
t.Fatalf("老通道的汇总口径 = %q,期望默认值 avg(等于升级前的「按成员平均」)", mode)
}
// 取值只有 avg / sum:拼错的必须被 CHECK 挡下,而不是静默当成某个口径。
if _, err := db.Exec(`INSERT INTO event_score_channels(event_id, scope, basis, profile_id, sort_order, aggregate_mode)
VALUES (1, 'athlete', 'aggregate', ?, 2, 'biggest')`, teamProfile); err == nil {
t.Fatal("非法 aggregate_mode 应被 CHECK 拒绝")
}
if _, err := db.Exec(`INSERT INTO event_score_channels(event_id, scope, basis, profile_id, sort_order, aggregate_mode)
VALUES (1, 'athlete', 'aggregate', ?, 2, 'sum')`, teamProfile); err != nil {
t.Fatalf("写入 sum 口径应成功: %v", err)
}
// 幂等:再跑一次不报错、行数不变、登记仍只有一条。
if err := store.MigrateEvent(db); err != nil {
t.Fatalf("重复升级应无副作用: %v", err)
}
var rows, registered int
if err := db.QueryRow(`SELECT COUNT(*) FROM event_score_channels`).Scan(&rows); err != nil {
t.Fatalf("统计通道: %v", err)
}
if rows != 2 {
t.Fatalf("通道数 = %d,期望 2", rows)
}
if err := db.QueryRow(`SELECT COUNT(*) FROM schema_migrations WHERE name = '0023_channel_aggregate_mode.sql'`).Scan(&registered); err != nil {
t.Fatalf("查询迁移登记: %v", err)
}
if registered != 1 {
t.Fatalf("迁移登记数 = %d,期望 1", registered)
}
}