AskaEth
877ff15823
## 算分正确性（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 的双通道形态按要求改变。
526 lines
17 KiB
Go
526 lines
17 KiB
Go
package realtime
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"git.yeij.top/AskaEth/Scoreboard/server/internal/domain"
|
|
"git.yeij.top/AskaEth/Scoreboard/server/internal/dto"
|
|
)
|
|
|
|
// latestResultsLimit 控制快照里「最新成绩」的行数上限，避免大屏首包过大。
|
|
// 行会按「小项 + 组别」聚合后再下发，因此组数只会比这个值更少。
|
|
const latestResultsLimit = 20
|
|
|
|
// Snapshot 是 snapshot 事件的 data，也是客户端冷启动的完整状态。
|
|
// 字段名与协议第 3 节一致；settings/standings/latestResults 的形状必须与 REST 同构，
|
|
// 否则大屏收到首包就会按错误的键名渲染。
|
|
type Snapshot struct {
|
|
Version int64 `json:"version"`
|
|
Settings dto.EventSettings `json:"settings"`
|
|
Teams []dto.Team `json:"teams"`
|
|
Events []dto.Event `json:"events"`
|
|
Standings []dto.StandingRow `json:"standings"`
|
|
Records []Record `json:"records"`
|
|
LatestResults []dto.EventResultGroup `json:"latestResults"`
|
|
}
|
|
|
|
// Record 是纪录榜的一行。
|
|
type Record struct {
|
|
ID int64 `json:"id"`
|
|
EventID int64 `json:"eventId"`
|
|
Level string `json:"level"`
|
|
ResultValue *float64 `json:"resultValue,omitempty"`
|
|
ResultText string `json:"resultText,omitempty"`
|
|
HolderName string `json:"holderName,omitempty"`
|
|
HolderTeamID int64 `json:"holderTeamId,omitempty"`
|
|
AchievedAt string `json:"achievedAt,omitempty"`
|
|
IsCurrent bool `json:"isCurrent"`
|
|
Source string `json:"source"`
|
|
}
|
|
|
|
// Snapshot 读取一份一致的完整状态。
|
|
//
|
|
// 全部查询放在同一个只读事务里，且版本号取自同一事务，
|
|
// 否则快照里的数据与版本号会错位，重连补齐时就会漏变更。
|
|
func (h *Hub) Snapshot(ctx context.Context) (*Snapshot, error) {
|
|
if h.db == nil {
|
|
return nil, fmt.Errorf("实时中心未绑定赛事库")
|
|
}
|
|
|
|
tx, err := h.db.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("开启快照事务: %w", err)
|
|
}
|
|
defer func() { _ = tx.Rollback() }()
|
|
|
|
snap := &Snapshot{
|
|
Teams: []dto.Team{},
|
|
Events: []dto.Event{},
|
|
Standings: []dto.StandingRow{},
|
|
Records: []Record{},
|
|
LatestResults: []dto.EventResultGroup{},
|
|
}
|
|
|
|
if err := tx.QueryRowContext(ctx, `SELECT COALESCE(MAX(id), 0) FROM change_log`).Scan(&snap.Version); err != nil {
|
|
return nil, fmt.Errorf("读取快照版本号: %w", err)
|
|
}
|
|
values, err := loadSettings(ctx, tx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := fillSettings(ctx, tx, values, snap); err != nil {
|
|
return nil, err
|
|
}
|
|
teams, err := loadTeams(ctx, tx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
snap.Teams = dto.TeamsFromDomain(teams)
|
|
if err := loadEvents(ctx, tx, snap); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := loadStandings(ctx, tx, snap, teams, values); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := loadRecords(ctx, tx, snap); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := loadLatestResults(ctx, tx, snap); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return nil, fmt.Errorf("提交快照事务: %w", err)
|
|
}
|
|
return snap, nil
|
|
}
|
|
|
|
// loadSettings 原样读出 settings 表的键值：榜单口径要用原始字符串，
|
|
// 而线上结构需要聚合后的嵌套对象，两者由调用方分别消费。
|
|
func loadSettings(ctx context.Context, tx *sql.Tx) (map[string]string, error) {
|
|
rows, err := tx.QueryContext(ctx, `SELECT key, value FROM settings`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("读取赛事配置: %w", err)
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
|
|
out := make(map[string]string)
|
|
for rows.Next() {
|
|
var key, value string
|
|
if err := rows.Scan(&key, &value); err != nil {
|
|
return nil, fmt.Errorf("解析赛事配置: %w", err)
|
|
}
|
|
out[key] = value
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
// fillSettings 聚合成与 REST /api/settings 相同的嵌套结构。
|
|
// defaultProfileId 在 settings 表里存的是模板 code，需要反查一次主键。
|
|
func fillSettings(ctx context.Context, tx *sql.Tx, values map[string]string, snap *Snapshot) error {
|
|
snap.Settings = dto.ParseEventSettings(values)
|
|
|
|
code := values["scoring.default_profile"]
|
|
if code == "" {
|
|
return nil
|
|
}
|
|
var id int64
|
|
err := tx.QueryRowContext(ctx, `SELECT id FROM scoring_profiles WHERE code = ?`, code).Scan(&id)
|
|
switch {
|
|
case errors.Is(err, sql.ErrNoRows):
|
|
// 配置引用的模板已被删除：保持 null，与 REST 一致，由管理端提示重选。
|
|
case err != nil:
|
|
return fmt.Errorf("解析默认积分模板: %w", err)
|
|
default:
|
|
snap.Settings.DefaultProfileID = &id
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// loadTeams 读取全量单位表（含停用单位）：榜单展示字段要与 REST 一致，
|
|
// 停用但仍有流水的单位也必须能补出编码/名称/颜色，否则大屏会出现空白行。
|
|
func loadTeams(ctx context.Context, tx *sql.Tx) ([]domain.Team, error) {
|
|
rows, err := tx.QueryContext(ctx, `
|
|
SELECT id, code, name, COALESCE(short_name, ''), COALESCE(logo_path, ''),
|
|
COALESCE(color, ''), sort_order, active
|
|
FROM teams
|
|
ORDER BY sort_order, code`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("读取单位: %w", err)
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
|
|
out := make([]domain.Team, 0)
|
|
for rows.Next() {
|
|
var (
|
|
t domain.Team
|
|
active int
|
|
)
|
|
if err := rows.Scan(&t.ID, &t.Code, &t.Name, &t.ShortName, &t.LogoPath, &t.Color, &t.SortOrder, &active); err != nil {
|
|
return nil, fmt.Errorf("解析单位: %w", err)
|
|
}
|
|
t.Active = active != 0
|
|
out = append(out, t)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func loadEvents(ctx context.Context, tx *sql.Tx, snap *Snapshot) error {
|
|
rows, err := tx.QueryContext(ctx, `
|
|
SELECT id, sport_id, code, name, event_type, result_mode, result_type, compare,
|
|
record_eligible, scored, multiplier, status,
|
|
COALESCE(scheduled_at, ''), COALESCE(venue, ''), sort_order, COALESCE(remark, ''), avg_mode
|
|
FROM events
|
|
ORDER BY sort_order, id`)
|
|
if err != nil {
|
|
return fmt.Errorf("读取小项: %w", err)
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
|
|
for rows.Next() {
|
|
var (
|
|
e domain.Event
|
|
eventType string
|
|
resultMode string
|
|
resultType string
|
|
compare string
|
|
status string
|
|
recordEligible int
|
|
scored int
|
|
)
|
|
if err := rows.Scan(
|
|
&e.ID, &e.SportID, &e.Code, &e.Name, &eventType, &resultMode, &resultType, &compare,
|
|
&recordEligible, &scored, &e.Multiplier, &status,
|
|
&e.ScheduledAt, &e.Venue, &e.SortOrder, &e.Remark, &e.AvgMode,
|
|
); err != nil {
|
|
return fmt.Errorf("解析小项: %w", err)
|
|
}
|
|
e.EventType = domain.EventType(eventType)
|
|
e.ResultMode = domain.ResultMode(resultMode)
|
|
e.ResultType = domain.ResultType(resultType)
|
|
e.Compare = domain.CompareMode(compare)
|
|
e.Status = domain.EventStatus(status)
|
|
e.RecordEligible = recordEligible != 0
|
|
e.Scored = scored != 0
|
|
snap.Events = append(snap.Events, dto.EventFromDomain(e))
|
|
}
|
|
return rows.Err()
|
|
}
|
|
|
|
// loadStandings 复用 domain 的排名口径，且输入与 REST /api/standings 完全一致：
|
|
// 排名输入只含启用单位，展示字段用全量单位表补齐；个人流水按系数折算、奖牌开关生效、
|
|
// 只有配了计分通道的项目才产出名次，排序键取自规则包落库的 standings.tie_break。
|
|
func loadStandings(ctx context.Context, tx *sql.Tx, snap *Snapshot, teams []domain.Team, values map[string]string) error {
|
|
ledger, err := loadLedger(ctx, tx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ranked, err := loadRanked(ctx, tx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
activeTeams := make([]domain.Team, 0, len(teams))
|
|
for _, t := range teams {
|
|
if t.Active {
|
|
activeTeams = append(activeTeams, t)
|
|
}
|
|
}
|
|
in := domain.StandingsInput{
|
|
Teams: activeTeams,
|
|
Ledger: ledger,
|
|
Ranked: ranked,
|
|
TieBreak: splitTieBreak(values["standings.tie_break"]),
|
|
IndividualToTeamWeight: atofDefault(values["standings.individual_to_team_weight"], 1),
|
|
ExcludeTeamEventMedals: !boolDefault(values["standings.medal_counts_team_events"], true),
|
|
}
|
|
// 单位奖牌榜的名次独立于总积分榜（金→银→铜→编码），随 medalRank 下发；
|
|
// 与 REST、xlsx 导出走的是同一个 domain.BuildMedalStandings。
|
|
snap.Standings = dto.StandingRows(
|
|
domain.BuildTeamStandings(in),
|
|
domain.BuildMedalStandings(in),
|
|
teams,
|
|
)
|
|
return nil
|
|
}
|
|
|
|
// splitTieBreak 解析 standings.tie_break（逗号分隔的排序键）；空串返回 nil，由 domain 落回默认口径。
|
|
func splitTieBreak(raw string) []string {
|
|
parts := strings.Split(raw, ",")
|
|
out := make([]string, 0, len(parts))
|
|
for _, p := range parts {
|
|
if p = strings.TrimSpace(p); p != "" {
|
|
out = append(out, p)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func loadLedger(ctx context.Context, tx *sql.Tx) ([]domain.LedgerEntry, error) {
|
|
rows, err := tx.QueryContext(ctx, `
|
|
SELECT id, team_id, COALESCE(athlete_id, 0), COALESCE(event_id, 0),
|
|
COALESCE(entry_id, 0), COALESCE(result_id, 0), source_type, source_id, points, count_to_team
|
|
FROM score_ledger WHERE voided = 0 ORDER BY id`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("读取积分流水: %w", err)
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
|
|
var out []domain.LedgerEntry
|
|
for rows.Next() {
|
|
var (
|
|
e domain.LedgerEntry
|
|
sourceType string
|
|
countToTeam int
|
|
)
|
|
if err := rows.Scan(&e.ID, &e.TeamID, &e.AthleteID, &e.EventID, &e.EntryID, &e.ResultID, &sourceType, &e.SourceID, &e.Points, &countToTeam); err != nil {
|
|
return nil, fmt.Errorf("解析积分流水: %w", err)
|
|
}
|
|
e.SourceType = domain.SourceType(sourceType)
|
|
e.CountToTeam = countToTeam != 0
|
|
out = append(out, e)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
// loadRanked 与 REST 的 buildRanked、导出的 loadRanked 同源：数据源是发布/重算时
|
|
// 按通道全量重建的 channel_ranks，一条名次一行（多通道项目因此不会把一枚奖牌算成多枚，
|
|
// 没配通道的项目也不会有名次行）。三个奖牌开关随行携带，domain 这边不必回查库；
|
|
// 同时排除只排名不计分（scored=0）的项目，与导出侧口径一致。
|
|
func loadRanked(ctx context.Context, tx *sql.Tx) ([]domain.RankedResult, error) {
|
|
rows, err := tx.QueryContext(ctx, `
|
|
SELECT COALESCE(cr.result_id, 0), cr.event_id, cr.category_id, cr.rank, cr.result_value, cr.status,
|
|
COALESCE(cr.entry_id, 0), COALESCE(cr.team_id, 0), COALESCE(cr.athlete_id, 0),
|
|
COALESCE(a.name, ''), cr.scope, cr.channel_id, cr.basis, cr.subject_key,
|
|
ev.award_medals, c.count_to_medals, c.count_to_team_medals
|
|
FROM channel_ranks cr
|
|
JOIN events ev ON ev.id = cr.event_id AND ev.scored = 1
|
|
JOIN event_score_channels c ON c.id = cr.channel_id
|
|
LEFT JOIN athletes a ON a.id = cr.athlete_id
|
|
WHERE cr.rank > 0
|
|
ORDER BY cr.event_id, cr.category_id, c.sort_order, c.id, cr.rank, cr.id`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("读取奖牌名次: %w", err)
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
|
|
var out []domain.RankedResult
|
|
for rows.Next() {
|
|
var (
|
|
rr domain.RankedResult
|
|
value sql.NullFloat64
|
|
status sql.NullString
|
|
awardMedals int
|
|
countToMedals int
|
|
countToTeamMedals int
|
|
)
|
|
if err := rows.Scan(&rr.ResultID, &rr.EventID, &rr.CategoryID, &rr.Rank, &value, &status,
|
|
&rr.EntryID, &rr.TeamID, &rr.AthleteID, &rr.AthleteName, &rr.Scope, &rr.ChannelID,
|
|
&rr.Basis, &rr.SubjectKey, &awardMedals, &countToMedals, &countToTeamMedals); err != nil {
|
|
return nil, fmt.Errorf("解析奖牌名次: %w", err)
|
|
}
|
|
rr.Status = domain.ResultStatus(status.String)
|
|
if value.Valid {
|
|
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)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func loadRecords(ctx context.Context, tx *sql.Tx, snap *Snapshot) error {
|
|
rows, err := tx.QueryContext(ctx, `
|
|
SELECT id, event_id, level, result_value, COALESCE(result_text, ''),
|
|
COALESCE(holder_name, ''), COALESCE(holder_team_id, 0),
|
|
COALESCE(achieved_at, ''), is_current, source
|
|
FROM records WHERE is_current = 1
|
|
ORDER BY event_id, level, id`)
|
|
if err != nil {
|
|
return fmt.Errorf("读取纪录榜: %w", err)
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
|
|
for rows.Next() {
|
|
var (
|
|
r Record
|
|
value sql.NullFloat64
|
|
isCurrent int
|
|
)
|
|
if err := rows.Scan(&r.ID, &r.EventID, &r.Level, &value, &r.ResultText,
|
|
&r.HolderName, &r.HolderTeamID, &r.AchievedAt, &isCurrent, &r.Source); err != nil {
|
|
return fmt.Errorf("解析纪录: %w", err)
|
|
}
|
|
if value.Valid {
|
|
v := value.Float64
|
|
r.ResultValue = &v
|
|
}
|
|
r.IsCurrent = isCurrent != 0
|
|
snap.Records = append(snap.Records, r)
|
|
}
|
|
return rows.Err()
|
|
}
|
|
|
|
// loadLatestResults 取最近发布的成绩，按「小项 + 组别」聚合成组后下发。
|
|
// 已作废（status=withdrawn）的成绩必须排除，否则大屏会继续展示被作废的行；
|
|
// 前端按组渲染（TickerBar 取最新一组、EventResultsPage 取前 N 组），平铺行会让它拿到 undefined。
|
|
func loadLatestResults(ctx context.Context, tx *sql.Tx, snap *Snapshot) error {
|
|
rows, err := tx.QueryContext(ctx, `
|
|
SELECT r.event_id, COALESCE(ev.code, ''), COALESCE(ev.name, ''),
|
|
e.category_id, COALESCE(cat.name, ''),
|
|
COALESCE(r.verified_at, r.recorded_at, r.updated_at, r.created_at, ''),
|
|
r.entry_id, r.rank, e.team_id,
|
|
COALESCE(t.code, ''), COALESCE(t.name, ''), COALESCE(t.short_name, ''), t.logo_path,
|
|
e.athlete_id, COALESCE(a.name, ''), COALESCE(e.member_names, ''),
|
|
COALESCE(r.result_text, ''), r.result_value, COALESCE(r.unit, ''), r.is_tie, r.status
|
|
FROM results r
|
|
JOIN entries e ON e.id = r.entry_id
|
|
JOIN events ev ON ev.id = r.event_id
|
|
LEFT JOIN event_categories cat ON cat.id = e.category_id
|
|
LEFT JOIN teams t ON t.id = e.team_id
|
|
LEFT JOIN athletes a ON a.id = e.athlete_id
|
|
WHERE r.state = 'published' AND r.status <> 'withdrawn'
|
|
ORDER BY COALESCE(r.verified_at, r.recorded_at, r.updated_at, r.created_at) DESC, r.id DESC
|
|
LIMIT ?`, latestResultsLimit)
|
|
if err != nil {
|
|
return fmt.Errorf("读取最新成绩: %w", err)
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
|
|
type groupKey struct {
|
|
eventID int64
|
|
categoryID int64
|
|
}
|
|
index := make(map[groupKey]int)
|
|
|
|
for rows.Next() {
|
|
var (
|
|
eventID, categoryID int64
|
|
eventCode, eventName string
|
|
categoryName string
|
|
publishedAt string
|
|
row dto.EventResultRow
|
|
rank sql.NullInt64
|
|
value sql.NullFloat64
|
|
athleteID sql.NullInt64
|
|
athleteName string
|
|
shortName string
|
|
logoPath sql.NullString
|
|
memberNames string
|
|
isTie int
|
|
)
|
|
if err := rows.Scan(&eventID, &eventCode, &eventName, &categoryID, &categoryName, &publishedAt,
|
|
&row.EntryID, &rank, &row.TeamID, &row.TeamCode, &row.TeamName, &shortName, &logoPath,
|
|
&athleteID, &athleteName, &memberNames,
|
|
&row.ResultText, &value, &row.Unit, &isTie, &row.Status); err != nil {
|
|
return fmt.Errorf("解析最新成绩: %w", err)
|
|
}
|
|
if rank.Valid {
|
|
v := int(rank.Int64)
|
|
row.Rank = &v
|
|
}
|
|
if value.Valid {
|
|
v := value.Float64
|
|
row.ResultValue = &v
|
|
}
|
|
if athleteID.Valid && athleteID.Int64 != 0 {
|
|
v := athleteID.Int64
|
|
row.AthleteID = &v
|
|
}
|
|
row.AthleteName = nilIfEmpty(athleteName)
|
|
row.ShortName = nilIfEmpty(shortName)
|
|
row.LogoPath = nilIfEmpty(logoPath.String)
|
|
row.MemberNames = parseMemberNames(memberNames)
|
|
row.IsTie = isTie != 0
|
|
|
|
key := groupKey{eventID: eventID, categoryID: categoryID}
|
|
i, ok := index[key]
|
|
if !ok {
|
|
i = len(snap.LatestResults)
|
|
index[key] = i
|
|
snap.LatestResults = append(snap.LatestResults, dto.EventResultGroup{
|
|
EventID: eventID,
|
|
EventCode: eventCode,
|
|
EventName: eventName,
|
|
CategoryID: categoryID,
|
|
CategoryName: categoryName,
|
|
PublishedAt: nilIfEmpty(publishedAt),
|
|
Rows: []dto.EventResultRow{},
|
|
})
|
|
}
|
|
snap.LatestResults[i].Rows = append(snap.LatestResults[i].Rows, row)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return err
|
|
}
|
|
|
|
// 行按发布时间倒序取回，组内需改回名次顺序；无名次的排最后。
|
|
for i := range snap.LatestResults {
|
|
sort.SliceStable(snap.LatestResults[i].Rows, func(a, b int) bool {
|
|
ra, rb := snap.LatestResults[i].Rows[a], snap.LatestResults[i].Rows[b]
|
|
switch {
|
|
case ra.Rank == nil && rb.Rank == nil:
|
|
return ra.EntryID < rb.EntryID
|
|
case ra.Rank == nil:
|
|
return false
|
|
case rb.Rank == nil:
|
|
return true
|
|
default:
|
|
return *ra.Rank < *rb.Rank
|
|
}
|
|
})
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// parseMemberNames 解析 entries.member_names；空值或坏 JSON 一律当作「无成员名单」。
|
|
func parseMemberNames(raw string) []string {
|
|
if raw == "" {
|
|
return nil
|
|
}
|
|
var out []string
|
|
if err := json.Unmarshal([]byte(raw), &out); err != nil {
|
|
return nil
|
|
}
|
|
return out
|
|
}
|
|
|
|
func nilIfEmpty(s string) *string {
|
|
if s == "" {
|
|
return nil
|
|
}
|
|
return &s
|
|
}
|
|
|
|
func atofDefault(v string, def float64) float64 {
|
|
n, err := strconv.ParseFloat(strings.TrimSpace(v), 64)
|
|
if err != nil {
|
|
return def
|
|
}
|
|
return n
|
|
}
|
|
|
|
func boolDefault(v string, def bool) bool {
|
|
switch strings.ToLower(strings.TrimSpace(v)) {
|
|
case "true", "1", "yes":
|
|
return true
|
|
case "false", "0", "no":
|
|
return false
|
|
default:
|
|
return def
|
|
}
|
|
}
|