feat: 大屏控制可看局域网设备并逐台切页 + 两种新导出(单页成绩 / 单位积分总明细)

## 大屏控制(用户:管理面板只能看到本机显示器,看不到局域网设备;也不能给某块屏单独切页)
- 服务端:`POST /api/display/command` 新增可选 `targets []string` —— 空 = 广播(公告语义不变),
  非空 = 只发给点名的实例并返回命中数;命中 0 个返回 404 +「目标大屏已离线,请刷新在线列表」
  (不落审计、公告也不落库)。`DisplaySender` 签名随之扩展,新增
  `Hub.SendCommandToInstances`(与按房间的 SendCommand 并存)。
- 服务端:WS `hello` 新增可选 `screen`,`realtime.Instance` 新增 `Screen`(不带 omitempty,
  局域网浏览器恒为空串),这样管理端能把「本机显示器」与「在线实例」精确对上。
- 管理端「大屏控制」:写死的「在线看板」占位换成真实列表(5 秒轮询、页面隐藏停表),
  列出实例 id / 在线离线 / 落后 / 屏号或「局域网浏览器」/ 当前页 / 来源 / 心跳;
  每行可单独切页;本机显示器卡片补「当前页」与逐屏切页;离线时控件置灰并说明原因。
  页面下拉改为共用大屏那份页名清单(管理端两处标签随之变为「个人积分奖牌榜」「分项成绩」)。

## 导出(用户:保留多页工作簿的同时,再要一种全平铺单页;积分榜明细也要能导出)
- 新增 `GET /api/export/all-flat.xlsx` → `赛事成绩总表(单页).xlsx`:一个工作簿一张表,
  列 = 大项/小项/组别/名次/号码/单位/运动员-队/成绩/积分/状态/备注;前三列取
  `EventSheet` 的结构化字段(不解析标题),后 8 列就是 `eventColumns` 本身(append 拼出,
  两处不可能漂移)。**既有「全部」(all.xlsx,多 sheet)一字未动。**
- 新增 `GET /api/export/teams.xlsx` → `单位积分总明细.xlsx`:一张带「单位」列的总表 +
  每个有明细行的单位一张分表;**无明细行的单位不出分表**(空表没信息量,且会把假删除的
  隐藏单位名字重新印进导出件);已隐藏但有流水的单位照常出表(它在榜单上)。
- 积分榜页:页头「导出总明细」、单位明细面板「导出该单位明细」;导出页新增「全部(单页)」。

测试:服务端 12 包全绿 / 347 个测试函数;前端 vue-tsc 通过、184 例全过;Console 18 文件。
docs/ 与 devdocs/ 同步(含新增 Q65–Q70 与两轮进度记录)。
This commit is contained in:
AskaEth committed 2026-09-11 00:44:03 +08:00
1 parent 793d2ac064
commit 782a38f82f
33 files changed
+2473 -119

No files matched your search

+82
View File
@@ -0,0 +1,82 @@
package export
import (
"database/sql"
"io"
"github.com/xuri/excelize/v2"
)
// flatSheet 是「全部成绩(单页)」唯一那张表的表名。
const flatSheet = "全部成绩"
// FlatWorkbook 是「全部成绩(单页)」的内容:所有小项、所有成绩平铺在一张表里。
// 与「全部」多 sheet 工作簿同源(都来自 LoadEventWorkbook),只是排版方式不同。
type FlatWorkbook struct {
Meta Meta
Sheets []EventSheet
}
// flatColumns 是单页表的列:在分项成绩列前补「大项 / 小项 / 组别」三列,
// 让每行脱离 sheet 标题也能自解释;后 8 列直接复用 eventColumns,避免两处口径漂移。
var flatColumns = append([]column{
{"大项", 14, kindText},
{"小项", 18, kindText},
{"组别", 14, kindText},
}, eventColumns...)
// ExportFlatXLSX 导出「全部成绩(单页)」到 dst。
func ExportFlatXLSX(db *sql.DB, dst string, opts Options) error {
wb, err := LoadFlatWorkbook(db, opts)
if err != nil {
return err
}
f, err := flatFile(wb)
if err != nil {
return err
}
return saveWorkbook(f, dst)
}
// WriteFlatXLSX 把「全部成绩(单页)」写成 xlsx 流,供 HTTP 直接响应下载。
func WriteFlatXLSX(w io.Writer, wb FlatWorkbook) error {
f, err := flatFile(wb)
if err != nil {
return err
}
return f.Write(w)
}
// LoadFlatWorkbook 读取全部小项(eventID = 0)的成绩,保留「全部」多 sheet 版里的小项顺序。
func LoadFlatWorkbook(db *sql.DB, opts Options) (FlatWorkbook, error) {
events, err := LoadEventWorkbook(db, 0, opts)
if err != nil {
return FlatWorkbook{}, err
}
return FlatWorkbook{Meta: events.Meta, Sheets: events.Sheets}, nil
}
func flatFile(wb FlatWorkbook) (*excelize.File, error) {
return buildWorkbook(flatSheet, func(f *excelize.File, st *styleSet) error {
meta := wb.Meta.normalized()
name := sanitizeSheetName(flatSheet)
if err := addSheet(f, name); err != nil {
return err
}
return writeSheet(f, st, name, meta, sheetTitle(meta, flatSheet), flatColumns, flatRows(wb.Sheets))
})
}
// flatRows 把小项 sheet 按原顺序拼成一份平铺行,每行前面补上所属的大项 / 小项 / 组别。
// 大项、小项、组别直接取 EventSheet 的结构化字段(LoadEventWorkbook 建 sheet 时已填好),
// 不去解析 sheet 标题字符串。
func flatRows(sheets []EventSheet) [][]any {
var out [][]any
for _, sh := range sheets {
ctx := []any{sh.SportName, sh.EventName, sh.Category}
for _, row := range eventRows(sh.Rows) {
out = append(out, append(append([]any{}, ctx...), row...))
}
}
return out
}
+183
View File
@@ -0,0 +1,183 @@
package export
import (
"database/sql"
"path/filepath"
"testing"
)
// seedSecondSport 再造一个大项下的小项(1 个组别 1 条成绩),
// 用于验证「大项 / 小项 / 组别」三列在多个小项之间不会串行。
func seedSecondSport(t *testing.T, db *sql.DB) {
t.Helper()
stmts := []string{
`INSERT INTO sports(code, name) VALUES ('SP2', '游泳')`,
`INSERT INTO events(sport_id, code, name, event_type, result_mode, result_type, compare, status)
VALUES (2, 'E2', '50米自由泳', 'individual', 'auto', 'time', 'asc', 'published')`,
`INSERT INTO event_categories(event_id, name, sort_order) VALUES (2, '女子', 1)`,
`INSERT INTO event_score_channels(event_id, scope, basis, profile_id)
SELECT 2, 'athlete', 'result', id FROM scoring_profiles WHERE code = 'individual_top6'`,
`INSERT INTO entries(event_id, category_id, team_id, athlete_id, bib) VALUES (2, 2, 1, 1, '201')`,
`INSERT INTO results(event_id, entry_id, rank, result_text, result_value, unit, state)
VALUES (2, 3, 1, '28.30', 28.30, 's', 'published')`,
`INSERT INTO score_ledger(team_id, athlete_id, event_id, entry_id, result_id, source_type, source_id, points)
VALUES (1, 1, 2, 3, 3, 'result', 3, 9)`,
}
for _, s := range stmts {
if _, err := db.Exec(s); err != nil {
t.Fatalf("造数据 %q: %v", s, err)
}
}
}
// 单页导出:只有一个 sheet,行数是全部小项 sheet 行数之和,前三列标注所属小项。
func TestExportFlatXLSX(t *testing.T) {
db := openEventDB(t)
seedEvent(t, db)
seedSecondSport(t, db)
dst := filepath.Join(t.TempDir(), "单页.xlsx")
if err := ExportFlatXLSX(db, dst, Options{}); err != nil {
t.Fatalf("导出单页总表: %v", err)
}
f := openXLSX(t, dst)
defer func() { _ = f.Close() }()
if got := f.GetSheetList(); !equalStrings(got, []string{flatSheet}) {
t.Fatalf("sheet 列表 = %v,期望只有 %s", got, flatSheet)
}
rows, err := f.GetRows(flatSheet)
if err != nil {
t.Fatalf("读取单页总表: %v", err)
}
// 4 行版式 + 小项 1 的 2 条成绩(两个单位各 1 条)+ 小项 2 的 1 条成绩
if len(rows) != 7 {
t.Fatalf("单页总表行数 = %d,期望 7", len(rows))
}
wantHeader := []string{"大项", "小项", "组别", "名次", "号码", "单位", "运动员/队", "成绩", "积分", "状态", "备注"}
for i, want := range wantHeader {
if got := cell(rows, 3, i); got != want {
t.Errorf("表头第 %d 列 = %q,期望 %q", i, got, want)
}
}
// 小项 1:田径 / 100米跑 / 男子。
first := []string{"田径", "100米跑", "男子", "1", "101", "第一分公司", "张三", "11.58 秒", "10", "有效"}
for i, want := range first {
if got := cell(rows, 4, i); got != want {
t.Errorf("第 1 行第 %d 列 = %q,期望 %q", i, got, want)
}
}
// 同一个小项的第二条成绩:三列保持该小项,不随行变。
sameEvent := []string{"田径", "100米跑", "男子", "2", "102", "第二分公司", "李四", "11.90 秒", "8", "有效"}
for i, want := range sameEvent {
if got := cell(rows, 5, i); got != want {
t.Errorf("第 2 行第 %d 列 = %q,期望 %q", i, got, want)
}
}
// 小项 2:游泳 / 50米自由泳 / 女子——三列必须跟着换,不能沿用上一个小项。
second := []string{"游泳", "50米自由泳", "女子", "1", "201", "第一分公司", "张三", "28.30 秒", "9", "有效"}
for i, want := range second {
if got := cell(rows, 6, i); got != want {
t.Errorf("第 3 行第 %d 列 = %q,期望 %q", i, got, want)
}
}
}
// 与「全部」(all.xlsx)逐格一致:同一个小项的行,除新增三列外每个单元格都相同。
func TestFlatMatchesAllXLSX(t *testing.T) {
db := openEventDB(t)
seedEvent(t, db)
seedSecondSport(t, db)
allDst := filepath.Join(t.TempDir(), "全部.xlsx")
if err := ExportAllXLSX(db, allDst, Options{}); err != nil {
t.Fatalf("导出全部: %v", err)
}
flatDst := filepath.Join(t.TempDir(), "单页.xlsx")
if err := ExportFlatXLSX(db, flatDst, Options{}); err != nil {
t.Fatalf("导出单页总表: %v", err)
}
allF := openXLSX(t, allDst)
defer func() { _ = allF.Close() }()
flatF := openXLSX(t, flatDst)
defer func() { _ = flatF.Close() }()
flatRows, err := flatF.GetRows(flatSheet)
if err != nil {
t.Fatalf("读取单页总表: %v", err)
}
// 判断哪个分项 sheet 对应哪组结构化数据:直接重新加载一次,顺序与写 sheet 时一致,
// 不用去解析 sheet 名或标题字符串。
wb, err := LoadAllWorkbook(db, Options{})
if err != nil {
t.Fatalf("读取全部: %v", err)
}
// 「全部」前 3 张是总表(总积分榜 / 团体奖牌榜 / 个人积分奖牌榜),其后才是分项 sheet。
sheets := allF.GetSheetList()
if len(sheets) != 3+len(wb.Events.Sheets) {
t.Fatalf("全部导出 sheet 列表 = %v,与 %d 个分项对不上", sheets, len(wb.Events.Sheets))
}
flatRow, compared := 4, 0
for si, name := range sheets[3:] {
sh := wb.Events.Sheets[si]
rows, err := allF.GetRows(name)
if err != nil {
t.Fatalf("读取分项 %s: %v", name, err)
}
// 版式为 1 标题 / 2 副标题 / 3 空行 / 4 表头,数据从第 5 行(索引 4)起。
dataRows := len(rows) - 4
for i := 0; i < dataRows; i++ {
for c := 0; c < len(eventColumns); c++ {
if got, want := cell(flatRows, flatRow+i, c+3), cell(rows, 4+i, c); got != want {
t.Errorf("分项 %s 第 %d 行第 %d 列:单页 %q,全部 %q", name, i, c, got, want)
}
}
// 新增的三列必须是该 sheet 所属的大项 / 小项 / 组别。
for c, want := range []string{sh.SportName, sh.EventName, sh.Category} {
if got := cell(flatRows, flatRow+i, c); got != want {
t.Errorf("分项 %s 第 %d 行第 %d 列 = %q,期望 %q", name, i, c, got, want)
}
}
compared++
}
flatRow += dataRows
}
// 行数 = 全部小项 sheet 的行数之和(+ 4 行版式)。
if flatRow != len(flatRows) {
t.Errorf("单页总表行数 = %d,期望 %d", len(flatRows), flatRow)
}
if compared != 3 {
t.Fatalf("比对的数据行数 = %d,期望 3", compared)
}
t.Logf("单页数据行三列: %v / %v / %v", flatRows[4][:3], flatRows[5][:3], flatRows[6][:3])
}
// 空赛事:返回一张只有标题与表头的工作簿,不报错。
func TestExportFlatXLSXEmptyEvent(t *testing.T) {
db := openEventDB(t)
dst := filepath.Join(t.TempDir(), "单页.xlsx")
if err := ExportFlatXLSX(db, dst, Options{}); err != nil {
t.Fatalf("空赛事导出单页总表: %v", err)
}
f := openXLSX(t, dst)
defer func() { _ = f.Close() }()
if got := f.GetSheetList(); !equalStrings(got, []string{flatSheet}) {
t.Fatalf("sheet 列表 = %v,期望只有 %s", got, flatSheet)
}
rows, err := f.GetRows(flatSheet)
if err != nil {
t.Fatalf("读取单页总表: %v", err)
}
if len(rows) != 4 { // 标题 / 副标题 / 空行 / 表头,没有数据行
t.Fatalf("空赛事单页总表行数 = %d,期望 4", len(rows))
}
if got := cell(rows, 3, 0); got != "大项" {
t.Errorf("空赛事表头首列 = %q,期望 大项", got)
}
}
+13 -6
View File
@@ -81,13 +81,14 @@ func teamDetailFile(wb TeamDetailWorkbook) (*excelize.File, error) {
})
}
// teamDetailRows 把明细行排成表格。与 REST 的单位积分明细同口径:
// teamDetailDataRows 生成明细的数据行(不含「合计」)并返回合计值。与 REST 的单位积分明细同口径:
// 记到个人的流水按 individual_to_team_weight 折算后展示,合计即各行之和。
func teamDetailRows(rows []TeamDetailRow, weight float64) [][]any {
// 总明细表复用它拼各单位的数据行,保证单表与总表逐格一致。
func teamDetailDataRows(rows []TeamDetailRow, weight float64) ([][]any, float64) {
if weight <= 0 {
weight = 1
}
out := make([][]any, 0, len(rows)+1)
out := make([][]any, 0, len(rows))
var total float64
for i, r := range rows {
points := r.Points
@@ -104,8 +105,14 @@ func teamDetailRows(rows []TeamDetailRow, weight float64) [][]any {
rank, r.ResultText, r.Source, points, r.Remark,
})
}
if len(rows) > 0 {
out = append(out, []any{"合计", "", "", "", "", "", "", "", total, ""})
return out, total
}
// teamDetailRows 把明细行排成表格:数据行后跟一行「合计」;没有流水时不加合计行。
func teamDetailRows(rows []TeamDetailRow, weight float64) [][]any {
data, total := teamDetailDataRows(rows, weight)
if len(data) == 0 {
return data
}
return out
return append(data, []any{"合计", "", "", "", "", "", "", "", total, ""})
}
+173
View File
@@ -0,0 +1,173 @@
package export
import (
"database/sql"
"io"
"sort"
"github.com/xuri/excelize/v2"
"git.yeij.top/AskaEth/Scoreboard/server/internal/domain"
)
// allTeamDetailsSheet 是总明细工作簿第一张总表的表名。
const allTeamDetailsSheet = "积分总明细"
// TeamDetailSheet 是总明细里某个单位的一张分表:列定义与单位明细完全一致。
// 只有有明细行的单位才会有分表(Rows 恒非空)。
type TeamDetailSheet struct {
Team domain.Team
Rows []TeamDetailRow
}
// AllTeamDetailsWorkbook 是「所有单位积分明细」(总明细)的内容:
// 第一张总表把所有单位的明细合在一起,其后每个有明细行的单位一张分表。
type AllTeamDetailsWorkbook struct {
Meta Meta
Sheets []TeamDetailSheet
IndividualToTeamWeight float64
}
// allTeamDetailColumns 是总表的列:在单位明细列的最前面加一列「单位」。
var allTeamDetailColumns = append([]column{{"单位", 22, kindText}}, teamDetailColumns...)
// ExportAllTeamDetailsXLSX 导出所有单位的积分明细(总表 + 每单位一张分表),落盘到 dst。
func ExportAllTeamDetailsXLSX(db *sql.DB, dst string, opts Options) error {
wb, err := LoadAllTeamDetailsWorkbook(db, opts)
if err != nil {
return err
}
f, err := allTeamDetailsFile(wb)
if err != nil {
return err
}
return saveWorkbook(f, dst)
}
// WriteAllTeamDetailsXLSX 把总明细写成 xlsx 流,供 HTTP 直接响应下载。
func WriteAllTeamDetailsXLSX(w io.Writer, wb AllTeamDetailsWorkbook) error {
f, err := allTeamDetailsFile(wb)
if err != nil {
return err
}
return f.Write(w)
}
func allTeamDetailsFile(wb AllTeamDetailsWorkbook) (*excelize.File, error) {
return buildWorkbook(allTeamDetailsSheet, func(f *excelize.File, st *styleSet) error {
meta := wb.Meta.normalized()
// 先登记总表名:分表即使和总表同名也会自动补后缀,不会撞名覆盖。
namer := &sheetNamer{}
master := namer.add(allTeamDetailsSheet)
if err := addSheet(f, master); err != nil {
return err
}
if err := writeSheet(f, st, master, meta, sheetTitle(meta, allTeamDetailsSheet),
allTeamDetailColumns, allTeamDetailRows(wb.Sheets, wb.IndividualToTeamWeight)); err != nil {
return err
}
for _, s := range wb.Sheets {
unit := displayName(s.Team.Name, s.Team.ShortName)
name := namer.add(unit + "积分明细")
if err := addSheet(f, name); err != nil {
return err
}
title := sheetTitle(meta, unit+" · 积分明细")
if err := writeSheet(f, st, name, meta, title, teamDetailColumns,
teamDetailRows(s.Rows, wb.IndividualToTeamWeight)); err != nil {
return err
}
}
return nil
})
}
// allTeamDetailRows 把各单位明细拼成一张总表。
// 逐单位复用 teamDetailDataRows(因此序号在每个单位内重新从 1 开始,折算口径与单位明细完全一致),
// 末尾补一行跨单位合计;即使一条流水都没有也保留合计行,保持版式一致。
func allTeamDetailRows(sheets []TeamDetailSheet, weight float64) [][]any {
var out [][]any
var total float64
for _, s := range sheets {
unit := displayName(s.Team.Name, s.Team.ShortName)
rows, sub := teamDetailDataRows(s.Rows, weight)
total += sub
for _, row := range rows {
out = append(out, append([]any{unit}, row...))
}
}
// 列序:单位 / 序号 / 大项 / 小项 / 组别 / 运动员 / 名次 / 成绩 / 来源 / 积分 / 备注。
return append(out, []any{"合计", "", "", "", "", "", "", "", "", total, ""})
}
// LoadAllTeamDetailsWorkbook 读取全量单位的积分流水。
// 单位顺序沿用「单位总分榜」(得分高的在前),与管理面板上看到的顺序一致;
// 榜上没有的单位(例如停用且没有任何流水/奖牌)按 teams.sort_order 排在其后。
// 只有真正有明细行的单位才进 Sheets:没有流水的单位既没有信息量,
// 也不能把「彻底删除」(假删除)后无流水的单位名字重新印进导出件。
func LoadAllTeamDetailsWorkbook(db *sql.DB, opts Options) (AllTeamDetailsWorkbook, error) {
if db == nil {
return AllTeamDetailsWorkbook{}, ErrNoDatabase
}
meta, settings, err := resolveMeta(db, opts.Meta)
if err != nil {
return AllTeamDetailsWorkbook{}, err
}
// 全量单位表:停用的单位也可能有历史流水,明细要能查到。
teams, err := loadTeams(db, false)
if err != nil {
return AllTeamDetailsWorkbook{}, err
}
order, err := teamStandingsOrder(db, opts)
if err != nil {
return AllTeamDetailsWorkbook{}, err
}
sort.SliceStable(teams, func(i, j int) bool {
oi, iok := order[teams[i].ID]
oj, jok := order[teams[j].ID]
if iok != jok {
return iok
}
if iok {
return oi < oj
}
// 都不在榜上时保持 loadTeams 的 sort_order, code 顺序。
return false
})
sheets := make([]TeamDetailSheet, 0, len(teams))
for _, t := range teams {
rows, err := loadTeamDetailRows(db, t.ID)
if err != nil {
return AllTeamDetailsWorkbook{}, err
}
// 没有明细行就不出分表。已隐藏(deleted_at 非空)但有流水的单位仍在榜单上,
// 照常出表;隐藏且无流水的单位不出表,否则等于把藏起来的条目印在导出件里。
if len(rows) == 0 {
continue
}
sheets = append(sheets, TeamDetailSheet{Team: t, Rows: rows})
}
return AllTeamDetailsWorkbook{
Meta: meta,
Sheets: sheets,
IndividualToTeamWeight: parseFloatDefault(settings["standings.individual_to_team_weight"], 1),
}, nil
}
// teamStandingsOrder 返回 单位ID → 总积分榜名次(0 起)。
// 名次规则只在 domain 里有一份,这里直接复用总积分榜的结果,不另算一套排序。
func teamStandingsOrder(db *sql.DB, opts Options) (map[int64]int, error) {
wb, err := LoadStandingsWorkbook(db, opts)
if err != nil {
return nil, err
}
order := make(map[int64]int, len(wb.Team))
for i, r := range wb.Team {
if _, ok := order[r.TeamID]; !ok {
order[r.TeamID] = i
}
}
return order, nil
}
+450
View File
@@ -0,0 +1,450 @@
package export
import (
"bytes"
"database/sql"
"path/filepath"
"strings"
"testing"
"github.com/xuri/excelize/v2"
)
const masterSheetName = "积分总明细"
// insertTeam 造一个单位;返回主键。
func insertTeam(t *testing.T, db *sql.DB, code, name, short string, sortOrder int, active bool) int64 {
t.Helper()
res, err := db.Exec(
`INSERT INTO teams(code, name, short_name, sort_order, active) VALUES (?, ?, ?, ?, ?)`,
code, name, short, sortOrder, active)
if err != nil {
t.Fatalf("造单位 %s: %v", code, err)
}
id, err := res.LastInsertId()
if err != nil {
t.Fatalf("取单位 id: %v", err)
}
return id
}
// insertLedger 给单位造一条人工调整流水(不挂小项,够触发一条明细行)。
func insertLedger(t *testing.T, db *sql.DB, teamID int64, points float64) {
t.Helper()
if _, err := db.Exec(
`INSERT INTO score_ledger(team_id, source_type, source_id, points) VALUES (?, 'adjustment', 99, ?)`,
teamID, points); err != nil {
t.Fatalf("造单位 %d 流水: %v", teamID, err)
}
}
// hideTeam 按 hideTeam 的真实语义「假删除」:只置 deleted_at 与 active = 0,数据全部保留。
func hideTeam(t *testing.T, db *sql.DB, teamID int64) {
t.Helper()
if _, err := db.Exec(
`UPDATE teams SET deleted_at = datetime('now'), active = 0 WHERE id = ?`, teamID); err != nil {
t.Fatalf("隐藏单位 %d: %v", teamID, err)
}
}
// 总表:第一列是「单位」,行数 = 各单位明细行数之和 + 合计行;分表与单位对得上。
func TestExportAllTeamDetailsXLSX(t *testing.T) {
db := openEventDB(t)
seedEvent(t, db)
dst := filepath.Join(t.TempDir(), "总明细.xlsx")
if err := ExportAllTeamDetailsXLSX(db, dst, Options{}); err != nil {
t.Fatalf("导出总明细: %v", err)
}
f, err := excelize.OpenFile(dst)
if err != nil {
t.Fatalf("重新打开 xlsx: %v", err)
}
defer func() { _ = f.Close() }()
// 单位顺序与「单位总分榜」一致:T1 10 分在前,T2 8 分在后。
want := []string{masterSheetName, "第一分公司积分明细", "第二分公司积分明细"}
if got := f.GetSheetList(); !equalStrings(got, want) {
t.Fatalf("sheet 列表 = %v,期望 %v", got, want)
}
master, err := f.GetRows(masterSheetName)
if err != nil {
t.Fatalf("读取总表: %v", err)
}
// 4 行版式 + 2 条明细(每单位 1 条)+ 1 行合计
if len(master) != 7 {
t.Fatalf("总表行数 = %d,期望 7", len(master))
}
if got := cell(master, 3, 0); got != "单位" {
t.Errorf("总表表头首列 = %q,期望 单位", got)
}
if got := cell(master, 3, 1); got != "序号" {
t.Errorf("总表表头第二列 = %q,期望 序号", got)
}
if got := cell(master, 3, 9); got != "积分" {
t.Errorf("总表表头积分列 = %q,期望 积分", got)
}
if got := cell(master, 3, 10); got != "备注" {
t.Errorf("总表表头末列 = %q,期望 备注", got)
}
if got := cell(master, 4, 0); got != "第一分公司" {
t.Errorf("首行单位 = %q,期望 第一分公司", got)
}
if got := cell(master, 4, 1); got != "1" {
t.Errorf("首行序号 = %q,期望 1", got)
}
if got := cell(master, 4, 2); got != "田径" {
t.Errorf("首行大项 = %q,期望 田径", got)
}
if got := cell(master, 4, 9); got != "10" {
t.Errorf("首行积分 = %q,期望 10", got)
}
if got := cell(master, 5, 0); got != "第二分公司" {
t.Errorf("次行单位 = %q,期望 第二分公司", got)
}
if got := cell(master, 6, 0); got != "合计" {
t.Errorf("合计行首列 = %q,期望 合计", got)
}
if got := cell(master, 6, 9); got != "18" {
t.Errorf("总合计 = %q,期望 18", got)
}
team, err := f.GetRows("第一分公司积分明细")
if err != nil {
t.Fatalf("读取分表: %v", err)
}
if len(team) != 6 { // 4 行版式 + 1 条明细 + 合计
t.Fatalf("第一分公司分表行数 = %d,期望 6", len(team))
}
if got := cell(team, 3, 0); got != "序号" {
t.Errorf("分表表头首列 = %q,期望 序号", got)
}
if got := cell(team, 5, 0); got != "合计" {
t.Errorf("分表合计行首列 = %q,期望 合计", got)
}
}
// 记到个人的流水折算后,总表 / 分表 / 单位明细端点三者必须逐格一致。
func TestAllTeamDetailsMatchesTeamDetail(t *testing.T) {
db := openEventDB(t)
seedEvent(t, db)
// 折算系数取非 1,确保比对的是折算后的数字而不是原始分。
if _, err := db.Exec(`UPDATE settings SET value = '0.5' WHERE key = 'standings.individual_to_team_weight'`); err != nil {
t.Fatalf("修改折算系数: %v", err)
}
single := filepath.Join(t.TempDir(), "单位明细.xlsx")
if err := ExportTeamDetailXLSX(db, 1, single, Options{}); err != nil {
t.Fatalf("导出单位明细: %v", err)
}
all := filepath.Join(t.TempDir(), "总明细.xlsx")
if err := ExportAllTeamDetailsXLSX(db, all, Options{}); err != nil {
t.Fatalf("导出总明细: %v", err)
}
fSingle := openXLSX(t, single)
defer func() { _ = fSingle.Close() }()
fAll := openXLSX(t, all)
defer func() { _ = fAll.Close() }()
singleRows, err := fSingle.GetRows("第一分公司积分明细")
if err != nil {
t.Fatalf("读取单位明细分表: %v", err)
}
allRows, err := fAll.GetRows("第一分公司积分明细")
if err != nil {
t.Fatalf("读取总明细分表: %v", err)
}
if !sameRows(singleRows, allRows) {
t.Fatalf("分表与单位明细端点不一致:\n单位明细 %v\n总明细分表 %v", singleRows, allRows)
}
master, err := fAll.GetRows(masterSheetName)
if err != nil {
t.Fatalf("读取总表: %v", err)
}
// 总表里同一单位的数据行:去掉首列「单位」后应与单位明细的数据行逐格相同。
teamRows := masterUnitRows(master, "第一分公司")
singleData := singleRows[4 : len(singleRows)-1]
if len(teamRows) != len(singleData) {
t.Fatalf("总表中第一分公司数据行数 = %d,单位明细 %d", len(teamRows), len(singleData))
}
for i := range teamRows {
if got := cell(teamRows, i, 0); got != "第一分公司" {
t.Errorf("总表第 %d 行单位列 = %q", i, got)
}
for c := range singleData[i] {
if got, want := cell(teamRows, i, c+1), cell(singleData, i, c); got != want {
t.Errorf("总表第 %d 行第 %d 列 = %q,单位明细 = %q", i, c, got, want)
}
}
}
// 折算后的实际数字:10 × 0.5 = 5,合计也是 5。
t.Logf("单位明细分表行: %v", singleRows[4])
t.Logf("总明细总表对应行: %v", teamRows[0])
t.Logf("总明细分表合计行: %v", allRows[len(allRows)-1])
if got := cell(allRows, 4, 8); got != "5" {
t.Errorf("分表折算后积分 = %q,期望 5", got)
}
if got := cell(allRows, 5, 8); got != "5" {
t.Errorf("分表合计 = %q,期望 5", got)
}
if got := cell(teamRows, 0, 9); got != "5" {
t.Errorf("总表折算后积分 = %q,期望 5", got)
}
if got := cell(master, 6, 9); got != "9" { // (10 + 8) × 0.5
t.Errorf("总表合计 = %q,期望 9", got)
}
}
// 两个单位简称相同时,分表名必须能区分,不能撞名或覆盖。
func TestAllTeamDetailsDedupesSheetNames(t *testing.T) {
db := openEventDB(t)
seedEvent(t, db)
insertLedger(t, db, insertTeam(t, db, "T3", "第一分公司", "三公司", 3, true), 1)
dst := filepath.Join(t.TempDir(), "总明细.xlsx")
if err := ExportAllTeamDetailsXLSX(db, dst, Options{}); err != nil {
t.Fatalf("导出总明细: %v", err)
}
f := openXLSX(t, dst)
defer func() { _ = f.Close() }()
want := []string{masterSheetName, "第一分公司积分明细", "第二分公司积分明细", "第一分公司积分明细(2)"}
if got := f.GetSheetList(); !equalStrings(got, want) {
t.Fatalf("sheet 列表 = %v,期望 %v", got, want)
}
// 两张同名单位分表都要有内容,不能被后写的覆盖。
for _, name := range []string{"第一分公司积分明细", "第一分公司积分明细(2)"} {
if _, err := f.GetRows(name); err != nil {
t.Errorf("读取 %s: %v", name, err)
}
}
}
// 长单位名截断到 31 字后撞名时也要能区分。
func TestAllTeamDetailsDedupesTruncatedSheetNames(t *testing.T) {
db := openEventDB(t)
seedEvent(t, db)
insertLedger(t, db, insertTeam(t, db, "T8", strings.Repeat("甲", 35)+"A", "", 3, true), 1)
insertLedger(t, db, insertTeam(t, db, "T9", strings.Repeat("甲", 35)+"B", "", 4, true), 1)
dst := filepath.Join(t.TempDir(), "总明细.xlsx")
if err := ExportAllTeamDetailsXLSX(db, dst, Options{}); err != nil {
t.Fatalf("导出总明细: %v", err)
}
f := openXLSX(t, dst)
defer func() { _ = f.Close() }()
want := []string{
masterSheetName, "第一分公司积分明细", "第二分公司积分明细",
strings.Repeat("甲", 31), strings.Repeat("甲", 28) + "(2)",
}
if got := f.GetSheetList(); !equalStrings(got, want) {
t.Fatalf("sheet 列表 = %v,期望 %v", got, want)
}
}
// 空赛事(一个单位都没有)要返回可用工作簿,而不是报错。
func TestAllTeamDetailsEmptyEvent(t *testing.T) {
db := openEventDB(t)
dst := filepath.Join(t.TempDir(), "总明细.xlsx")
if err := ExportAllTeamDetailsXLSX(db, dst, Options{}); err != nil {
t.Fatalf("空赛事导出: %v", err)
}
f := openXLSX(t, dst)
defer func() { _ = f.Close() }()
if got := f.GetSheetList(); !equalStrings(got, []string{masterSheetName}) {
t.Fatalf("sheet 列表 = %v,期望只有总表", got)
}
rows, err := f.GetRows(masterSheetName)
if err != nil {
t.Fatalf("读取总表: %v", err)
}
if len(rows) != 5 { // 4 行版式 + 空数据 + 合计行
t.Fatalf("总表行数 = %d,期望 5", len(rows))
}
if got := cell(rows, 3, 0); got != "单位" {
t.Errorf("空赛事表头首列 = %q,期望 单位", got)
}
if got := cell(rows, 4, 0); got != "合计" {
t.Errorf("空赛事合计行首列 = %q,期望 合计", got)
}
if got := cell(rows, 4, 9); got != "0" {
t.Errorf("空赛事合计 = %q,期望 0", got)
}
}
// 没有流水的单位不出分表,也不进总表。
func TestAllTeamDetailsSkipsTeamWithoutLedger(t *testing.T) {
db := openEventDB(t)
seedEvent(t, db)
insertTeam(t, db, "T3", "第三分公司", "三公司", 3, true)
dst := filepath.Join(t.TempDir(), "总明细.xlsx")
if err := ExportAllTeamDetailsXLSX(db, dst, Options{}); err != nil {
t.Fatalf("导出总明细: %v", err)
}
f := openXLSX(t, dst)
defer func() { _ = f.Close() }()
want := []string{masterSheetName, "第一分公司积分明细", "第二分公司积分明细"}
if got := f.GetSheetList(); !equalStrings(got, want) {
t.Fatalf("sheet 列表 = %v,期望 %v(无流水单位不出表)", got, want)
}
master, err := f.GetRows(masterSheetName)
if err != nil {
t.Fatalf("读取总表: %v", err)
}
if len(master) != 7 { // 仍只有 T1、T2 两条明细
t.Fatalf("总表行数 = %d,期望 7", len(master))
}
if got := masterUnitRows(master, "第三分公司"); len(got) != 0 {
t.Errorf("无流水单位不应出现在总表: %v", got)
}
}
// 已隐藏(deleted_at 非空)的单位:有流水照常出分表(它在总积分榜上),无流水绝不出表。
func TestAllTeamDetailsHiddenTeam(t *testing.T) {
db := openEventDB(t)
seedEvent(t, db)
// 隐藏但有流水:在总积分榜上(domain 会为流水兜底出行),导出必须与榜单一致。
scored := insertTeam(t, db, "H1", "被隐藏但有分", "隐藏一", 3, false)
insertLedger(t, db, scored, 7)
hideTeam(t, db, scored)
// 隐藏且无流水:正是用户想藏起来的条目,不能出现在导出件的任何地方。
silent := insertTeam(t, db, "H2", "被隐藏且无分", "隐藏二", 4, false)
hideTeam(t, db, silent)
dst := filepath.Join(t.TempDir(), "总明细.xlsx")
if err := ExportAllTeamDetailsXLSX(db, dst, Options{}); err != nil {
t.Fatalf("导出总明细: %v", err)
}
f := openXLSX(t, dst)
defer func() { _ = f.Close() }()
// 有流水的隐藏单位:单位总分榜第 3 名(10 / 8 / 7),分表必须存在。
want := []string{masterSheetName, "第一分公司积分明细", "第二分公司积分明细", "被隐藏但有分积分明细"}
if got := f.GetSheetList(); !equalStrings(got, want) {
t.Fatalf("sheet 列表 = %v,期望 %v", got, want)
}
rows, err := f.GetRows("被隐藏但有分积分明细")
if err != nil {
t.Fatalf("读取隐藏单位分表: %v", err)
}
if got := cell(rows, 4, 8); got != "7" {
t.Errorf("隐藏单位分表积分 = %q,期望 7", got)
}
master, err := f.GetRows(masterSheetName)
if err != nil {
t.Fatalf("读取总表: %v", err)
}
if got := masterUnitRows(master, "被隐藏但有分"); len(got) != 1 {
t.Errorf("有流水的隐藏单位应出现在总表,得到 %v", got)
}
// 无流水的隐藏单位:sheet 与总表里都不得出现它的名字。
for _, name := range f.GetSheetList() {
if strings.Contains(name, "无分") {
t.Errorf("无流水的隐藏单位不应出分表,却看到 %q", name)
}
}
if got := masterUnitRows(master, "被隐藏且无分"); len(got) != 0 {
t.Errorf("无流水的隐藏单位不应出现在总表: %v", got)
}
}
// 所有单位都没有流水:只剩一张总表,且生成的文件仍能被 excelize 正常解析。
func TestAllTeamDetailsNoLedgerAtAll(t *testing.T) {
db := openEventDB(t)
insertTeam(t, db, "T1", "第一分公司", "一公司", 1, true)
insertTeam(t, db, "T2", "第二分公司", "二公司", 2, true)
dst := filepath.Join(t.TempDir(), "总明细.xlsx")
if err := ExportAllTeamDetailsXLSX(db, dst, Options{}); err != nil {
t.Fatalf("无流水导出: %v", err)
}
// 真正的证据:重新打开文件解析,而不是只看写文件有没有报错。
f := openXLSX(t, dst)
defer func() { _ = f.Close() }()
if got := f.GetSheetList(); !equalStrings(got, []string{masterSheetName}) {
t.Fatalf("sheet 列表 = %v,期望只有总表", got)
}
rows, err := f.GetRows(masterSheetName)
if err != nil {
t.Fatalf("读取总表: %v", err)
}
if len(rows) != 5 { // 4 行版式 + 空数据 + 合计行
t.Fatalf("总表行数 = %d,期望 5", len(rows))
}
if got := cell(rows, 3, 0); got != "单位" {
t.Errorf("总表表头首列 = %q,期望 单位", got)
}
if got := cell(rows, 4, 0); got != "合计" {
t.Errorf("合计行首列 = %q,期望 合计", got)
}
}
func TestWriteAllTeamDetailsXLSXStream(t *testing.T) {
db := openEventDB(t)
seedEvent(t, db)
wb, err := LoadAllTeamDetailsWorkbook(db, Options{})
if err != nil {
t.Fatalf("读取总明细: %v", err)
}
var buf bytes.Buffer
if err := WriteAllTeamDetailsXLSX(&buf, wb); err != nil {
t.Fatalf("流式导出总明细: %v", err)
}
f, err := excelize.OpenReader(bytes.NewReader(buf.Bytes()))
if err != nil {
t.Fatalf("打开流式导出的 xlsx: %v", err)
}
defer func() { _ = f.Close() }()
if got := len(f.GetSheetList()); got != 3 {
t.Errorf("sheet 数 = %d,期望 3", got)
}
}
func openXLSX(t *testing.T, path string) *excelize.File {
t.Helper()
f, err := excelize.OpenFile(path)
if err != nil {
t.Fatalf("打开 %s: %v", path, err)
}
return f
}
// sameRows 逐格比较两份表格(越界按空字符串处理)。
func sameRows(a, b [][]string) bool {
n := len(a)
if len(b) > n {
n = len(b)
}
for r := 0; r < n; r++ {
for c := 0; c < 12; c++ {
if cell(a, r, c) != cell(b, r, c) {
return false
}
}
}
return true
}
// masterUnitRows 取总表里某个单位的数据行(排除合计行)。
func masterUnitRows(rows [][]string, unit string) [][]string {
var out [][]string
for r, row := range rows {
if r < 4 || cell(rows, r, 0) != unit {
continue
}
out = append(out, row)
}
return out
}