Scoreboard/server/internal/httpapi/rules_handlers.go

package httpapi

import (
	"context"
	"io"
	"net/http"

	"git.yeij.top/AskaEth/Scoreboard/server/internal/auth"
	"git.yeij.top/AskaEth/Scoreboard/server/internal/dto"
	"git.yeij.top/AskaEth/Scoreboard/server/internal/rules"
)

// rulesRoutes 挂载规则包的导出与导入（导入支持 ?preview=1 只预览差异）。
func (s *server) rulesRoutes(mux *http.ServeMux) {
	mux.HandleFunc("GET /api/rules/export", s.read(auth.RoleAdmin, s.exportRules))
	mux.HandleFunc("POST /api/rules/import", s.write(auth.RoleAdmin, s.importRules))
	// 录入员要判断破纪录加分/人工调整是否启用，但无权读 /api/settings，故单开只读开关。
	mux.HandleFunc("GET /api/rules/switches", s.read(auth.RoleRecorder, s.ruleSwitches))
}

// ruleSwitches 只返回布尔开关，不下发规则内容、模板明细或文件路径。
func (s *server) ruleSwitches(w http.ResponseWriter, r *http.Request) (any, error) {
	snap, err := rules.Load(s.ev)
	if err != nil {
		return nil, internal(err)
	}
	pack := snap.Pack
	return dto.RuleSwitches{
		RecordBonusEnabled:       pack.RecordBonus.Enabled,
		AdjustmentsEnabled:       pack.ManualAdjustment.Enabled,
		AdjustmentReasonRequired: pack.ManualAdjustment.ReasonRequired,
		MedalCountsTeamEvents:    pack.Standings.MedalCountsTeamEventsEnabled(),
		ShowIndividualBoard:      pack.Standings.ShowIndividualBoardEnabled(),
		ShowIndividualMedals:     pack.Standings.ShowIndividualMedalsEnabled(),
	}, nil
}

func (s *server) exportRules(w http.ResponseWriter, r *http.Request) (any, error) {
	pack, err := rules.Export(s.ev, rules.Meta{})
	if err != nil {
		return nil, internal(err)
	}
	body, err := rules.Marshal(pack)
	if err != nil {
		return nil, internal(err)
	}
	w.Header().Set("Content-Type", "application/yaml; charset=utf-8")
	w.Header().Set("Content-Disposition", `attachment; filename="rules.yaml"`)
	if _, err := w.Write(body); err != nil {
		s.logger.Error("规则包写出失败", "err", err)
	}
	return nil, errHandled
}

// rulesPackCompatible 判断规则包格式版本是否与当前程序一致。
func rulesPackCompatible(pack *rules.RulePack) bool {
	return pack.Format == rules.FormatName && pack.FormatVersion == rules.FormatVersion
}

// rulesImportPreview 是规则预览响应：在 ChangeSet 之上补齐前端契约里的兼容性与影响面。
type rulesImportPreview struct {
	*rules.ChangeSet
	// Compatible 由 formatVersion 判断；能解析到这里说明版本已兼容。
	Compatible         bool `json:"compatible"`
	AffectedEventCount int  `json:"affectedEventCount"`
}

// rulesImportResult 是规则落地响应：在 ApplyResult 之上补齐预览字段与重算条数。
// 同时带上 ChangeSet，前端落地后仍能显示这次导入的逐条差异（否则会被覆盖成「无差异」）。
type rulesImportResult struct {
	*rules.ApplyResult
	*rules.ChangeSet
	Compatible             bool `json:"compatible"`
	AffectedEventCount     int  `json:"affectedEventCount"`
	RecalculatedLedgerRows int  `json:"recalculatedLedgerRows"`
}

// affectedEventCount 统计本次导入影响的小项数：计分通道变化的项目，
// 加上引用了被改动模板的项目——模板分值一变，这些项目的积分就会跟着变。
func affectedEventCount(cs *rules.ChangeSet, cur *rules.Snapshot) int {
	affected := make(map[string]bool, len(cs.Channels))
	for _, ch := range cs.Channels {
		affected[ch.EventCode] = true
	}
	if len(cs.Profiles) > 0 {
		changed := make(map[string]bool, len(cs.Profiles))
		for _, pc := range cs.Profiles {
			changed[pc.Code] = true
		}
		for _, ev := range cur.Events {
			for _, ch := range ev.Channels {
				if changed[ch.Profile] {
					affected[ev.Code] = true
				}
			}
		}
	}
	return len(affected)
}

func (s *server) importRules(w http.ResponseWriter, r *http.Request) (any, error) {
	body, err := io.ReadAll(io.LimitReader(r.Body, 4<<20))
	if err != nil {
		return nil, badRequest("读取请求体失败", nil)
	}
	if len(body) == 0 {
		return nil, badRequest("请求体为空", nil)
	}

	pack, err := rules.Parse(body)
	if err != nil {
		return nil, badRequest(err.Error(), nil)
	}
	cur, err := rules.Load(s.ev)
	if err != nil {
		return nil, internal(err)
	}
	cs, err := rules.Diff(cur, pack)
	if err != nil {
		return nil, badRequest(err.Error(), nil)
	}

	// 先预览再落地：?preview=1 只返回差异。
	if r.URL.Query().Get("preview") == "1" {
		return rulesImportPreview{
			ChangeSet:          cs,
			Compatible:         rulesPackCompatible(pack),
			AffectedEventCount: affectedEventCount(cs, cur),
		}, nil
	}

	res, err := rules.Apply(s.ev, cs)
	if err != nil {
		return nil, internal(err)
	}
	// 分值一变，历史成绩的积分与名次必须全量重算。
	rows, err := s.recomputeAllEvents(r.Context(), middlewareUserID(r))
	if err != nil {
		// 规则已经落库、重算整体回滚，现场处于「新规则 + 旧积分」；
		// 必须显式告知调用方，不能报成功让操作员以为重算已完成。
		s.logger.Error("规则导入后重算失败", "err", err)
		return nil, &apiError{
			status:  http.StatusInternalServerError,
			code:    "INTERNAL",
			message: "规则已导入，但积分重算失败，成绩与积分尚未同步；请重试导入",
			detail:  err.Error(),
		}
	}
	s.audit(r.Context(), "rules.import", "rules", 0, nil, res)
	return rulesImportResult{
		ApplyResult:            res,
		ChangeSet:              cs,
		Compatible:             rulesPackCompatible(pack),
		AffectedEventCount:     affectedEventCount(cs, cur),
		RecalculatedLedgerRows: rows,
	}, nil
}

// recomputeAllEvents 全量重算所有项目的积分流水与名次，用于规则包导入等会改变分值的场景。
// 整个重算共用一个事务：任一项目失败就全部回滚，不会留下「只重算了一部分」的中间状态。
// 返回写入的积分流水条数，供导入结果回报。
func (s *server) recomputeAllEvents(ctx context.Context, actorID int64) (int, error) {
	rows, err := s.ev.QueryContext(ctx, `SELECT id FROM events ORDER BY id`)
	if err != nil {
		return 0, err
	}
	var ids []int64
	for rows.Next() {
		var id int64
		if err := rows.Scan(&id); err != nil {
			_ = rows.Close()
			return 0, err
		}
		ids = append(ids, id)
	}
	if err := rows.Close(); err != nil {
		return 0, err
	}
	if err := rows.Err(); err != nil {
		return 0, err
	}

	tx, err := s.ev.BeginTx(ctx, nil)
	if err != nil {
		return 0, err
	}
	defer func() { _ = tx.Rollback() }()

	total := 0
	for _, eventID := range ids {
		score, err := recomputeLedgerTx(ctx, tx, eventID, 0, actorID, "rules-import")
		if err != nil {
			return 0, err
		}
		// 名次随分值一起变化，必须回写 results，否则奖牌榜与积分榜互相矛盾。
		if err := applyComputedRanks(ctx, tx, score.Ranked); err != nil {
			return 0, err
		}
		total += len(score.Ledger)
	}
	// 重算改动了积分，必须写版本号并推送，否则大屏停在旧比分。
	if err := s.bumpStandings(ctx, tx, actorID); err != nil {
		return 0, err
	}
	if err := tx.Commit(); err != nil {
		return 0, err
	}
	return total, nil
}