754 lines
28 KiB
Go
754 lines
28 KiB
Go
// Copyright 2026 tamakyi. All rights reserved.
|
||
// Use of this source code is governed by a MIT-style
|
||
// license that can be found in the LICENSE file.
|
||
|
||
package db
|
||
|
||
import (
|
||
"context"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/pkg/errors"
|
||
"github.com/sirupsen/logrus"
|
||
"gorm.io/gorm"
|
||
"gorm.io/gorm/clause"
|
||
|
||
"github.com/tamakyi/TamaBox/internal/dbutil"
|
||
)
|
||
|
||
var FeatureControls FeatureControlsStore
|
||
|
||
var ErrFeatureQuotaReached = errors.New("功能收集配额已满")
|
||
|
||
var _ FeatureControlsStore = (*featureControls)(nil)
|
||
|
||
// 受控功能标识（feature_controls.feature 取值）。
|
||
const (
|
||
FeatureQuestion = "question" // 提问
|
||
FeatureChat = "chat" // 私聊
|
||
FeatureVote = "vote" // 投票
|
||
)
|
||
|
||
// FeatureKeys 全部受控功能，顺序即功能管理页的展示顺序。
|
||
var FeatureKeys = []string{FeatureQuestion, FeatureChat, FeatureVote}
|
||
|
||
// 功能不可用原因（空串表示可用）。
|
||
const (
|
||
FeatureReasonDisabled = "disabled" // 手动关闭
|
||
FeatureReasonNotStarted = "not_started" // 未到开放时间
|
||
FeatureReasonEnded = "ended" // 已过关闭时间
|
||
FeatureReasonQuotaReached = "quota_reached" // 已达定量收集上限
|
||
)
|
||
|
||
// QuotaLimitMax 单个功能的收集上限最大值，防止误填极大值。
|
||
const QuotaLimitMax = 1_000_000
|
||
|
||
type FeatureControlsStore interface {
|
||
// Get 读取某功能的配置；无记录时返回该功能的默认配置（不落库）。
|
||
Get(ctx context.Context, userID uint, feature string) (*FeatureControl, error)
|
||
// ListByUserID 读取某用户全部功能的配置（无记录的功能不出现在结果中）。
|
||
ListByUserID(ctx context.Context, userID uint) ([]*FeatureControl, error)
|
||
// ListByUserIDs 批量读取多个用户同一功能的配置（探索页等批量场景用，避免 N+1）。
|
||
ListByUserIDs(ctx context.Context, userIDs []uint, feature string) (map[uint]*FeatureControl, error)
|
||
// Save 写入配置（不存在则创建，存在则更新开关/时间窗/上限，不影响已收集计数）。
|
||
Save(ctx context.Context, userID uint, feature string, opts UpdateFeatureControlOptions) error
|
||
// ResetQuota 清零收集计数，重新开始一轮定量收集。
|
||
ResetQuota(ctx context.Context, userID uint, feature string) error
|
||
// IncrementQuota 累加收集计数；无记录时按 delta 创建。
|
||
IncrementQuota(ctx context.Context, userID uint, feature string, delta int64) error
|
||
}
|
||
|
||
func NewFeatureControlsStore(db *gorm.DB) FeatureControlsStore {
|
||
return &featureControls{db}
|
||
}
|
||
|
||
type featureControls struct {
|
||
*gorm.DB
|
||
}
|
||
|
||
// FeatureControl 单个功能（提问 / 私聊 / 投票）的开关、定时与定量收集配置。
|
||
// Enabled 为手动总开关；OpenAt / CloseAt 为一次性定时（nil 表示不限该侧）；
|
||
// QuotaLimit / QuotaCount 为定量收集（0 表示不限制）。最终状态由 Evaluate 综合计算。
|
||
//
|
||
// 计数不做定时重置：一轮结束后由箱主手动「重置计数」，避免与定时开关叠加产生
|
||
// 难以预期的自动恢复行为。
|
||
type FeatureControl struct {
|
||
dbutil.Model
|
||
UserID uint `gorm:"uniqueIndex:idx_feature_control_user_feature;not null" json:"-"`
|
||
Feature string `gorm:"size:20;uniqueIndex:idx_feature_control_user_feature;not null" json:"feature"`
|
||
// ⚠️ 不要给 Enabled 加 gorm:"default:true"：GORM 在 Create 时会把零值 false 替换为
|
||
// 默认值 true，导致「取消勾选保存」后库里仍是 true、复选框自动恢复勾选。
|
||
Enabled bool `json:"enabled"`
|
||
OpenAt *time.Time `json:"open_at"`
|
||
CloseAt *time.Time `json:"close_at"`
|
||
// 循环定时（每周）：ScheduleDays 为逗号分隔的周几（0=周日…6=周六），空表示每天都开放；
|
||
// ScheduleStart/ScheduleEnd 为每日时间段 "HH:MM"（留空表示全天）。两者皆空即未启用。
|
||
ScheduleDays string `gorm:"size:31" json:"schedule_days"`
|
||
ScheduleStart string `gorm:"size:5" json:"schedule_start"`
|
||
ScheduleEnd string `gorm:"size:5" json:"schedule_end"`
|
||
QuotaLimit int64 `gorm:"default:0" json:"quota_limit"`
|
||
QuotaCount int64 `gorm:"default:0" json:"quota_count"`
|
||
QuotaResetAt *time.Time `json:"quota_reset_at"`
|
||
}
|
||
|
||
// FeatureState 某功能在某一时刻的综合状态。
|
||
type FeatureState struct {
|
||
Enabled bool // 手动开关
|
||
Open bool // 综合（开关 + 定时 + 定量）后的最终可用状态
|
||
Reason string // 不可用原因，空串表示可用（取值见 FeatureReason*）
|
||
QuotaLimit int64 // 收集上限（0 = 不限制）
|
||
QuotaCount int64 // 已收集数量
|
||
OpenAt *time.Time // 一次性定时开放时间
|
||
CloseAt *time.Time // 一次性定时关闭时间
|
||
NextOpenAt *time.Time // 下一次开放时间（可能来自一次性窗口或循环定时；永久关闭时为 nil）
|
||
LastCloseAt *time.Time // 最近一次关闭时间（从未开放过时为 nil）
|
||
}
|
||
|
||
// Evaluate 计算该功能在 now 时刻的综合状态。
|
||
// 判定优先级：手动关闭 > 未到一次性开放时间 > 已过一次性关闭时间 > 不在循环定时窗口内 > 达到收集上限。
|
||
func (fc *FeatureControl) Evaluate(now time.Time) FeatureState {
|
||
st := FeatureState{
|
||
Enabled: fc.Enabled,
|
||
QuotaLimit: fc.QuotaLimit,
|
||
QuotaCount: fc.QuotaCount,
|
||
OpenAt: fc.OpenAt,
|
||
CloseAt: fc.CloseAt,
|
||
}
|
||
// 先算好下次开放 / 最近关闭，供 reason 判定与展示复用。
|
||
st.NextOpenAt = fc.nextOpenAt(now)
|
||
st.LastCloseAt = fc.lastCloseAt(now)
|
||
|
||
switch {
|
||
case !fc.Enabled:
|
||
st.Reason = FeatureReasonDisabled
|
||
// 手动关闭与时间无关，不展示开放/关闭时间
|
||
st.NextOpenAt, st.LastCloseAt = nil, nil
|
||
case fc.OpenAt != nil && now.Before(*fc.OpenAt):
|
||
st.Reason = FeatureReasonNotStarted
|
||
case fc.CloseAt != nil && !now.Before(*fc.CloseAt):
|
||
// 已过一次性关闭时间：一次性窗口是硬性外边界，循环定时仅在窗口内生效，
|
||
// 因此之后不会再开放（nextOpenAt 已按 CloseAt 约束计算，返回 nil）。
|
||
st.Reason = FeatureReasonEnded
|
||
st.NextOpenAt = nil
|
||
default:
|
||
switch fc.scheduleSlotStatus(now) {
|
||
case scheduleBeforeStart:
|
||
st.Reason = FeatureReasonNotStarted
|
||
case scheduleAfterEnd:
|
||
if st.NextOpenAt != nil {
|
||
st.Reason = FeatureReasonNotStarted
|
||
} else {
|
||
st.Reason = FeatureReasonEnded
|
||
}
|
||
}
|
||
if st.Reason == "" && fc.QuotaLimit > 0 && fc.QuotaCount >= fc.QuotaLimit {
|
||
st.Reason = FeatureReasonQuotaReached
|
||
// 定量上限与时间无关，不展示开放/关闭时间
|
||
st.NextOpenAt, st.LastCloseAt = nil, nil
|
||
}
|
||
}
|
||
st.Open = st.Reason == ""
|
||
return st
|
||
}
|
||
|
||
// scheduleSlotStatus 表示 now 相对循环定时窗口的位置。
|
||
type scheduleSlotStatus int
|
||
|
||
const (
|
||
scheduleInWindow scheduleSlotStatus = iota // 在开放窗口内
|
||
scheduleBeforeStart // 今天开放，但未到开始时间
|
||
scheduleAfterEnd // 已过结束时间，或今天不在开放日
|
||
)
|
||
|
||
// scheduleActive 判断是否启用了循环定时。
|
||
// 规则：设置了开放日，或同时设置了开始/结束时间，即视为启用；
|
||
// 只设置单侧时间视为配置异常，由路由层校验拦截。
|
||
func (fc *FeatureControl) scheduleActive() bool {
|
||
return fc.ScheduleDays != "" || (fc.ScheduleStart != "" && fc.ScheduleEnd != "")
|
||
}
|
||
|
||
// scheduleDayOpen 判断某天是否为开放日（ScheduleDays 为空 = 每天都开放）。
|
||
func (fc *FeatureControl) scheduleDayOpen(day time.Time) bool {
|
||
return fc.ScheduleDays == "" || containsWeekday(fc.ScheduleDays, int(day.Weekday()))
|
||
}
|
||
|
||
// scheduleWindow 返回单日开放窗口的分钟数 [startM, endM)。未设置时间段时视为全天；
|
||
// 配置非法时返回错误（调用方按「不限制」处理）。
|
||
func (fc *FeatureControl) scheduleWindow() (startM, endM int, err error) {
|
||
if fc.ScheduleStart == "" && fc.ScheduleEnd == "" {
|
||
return 0, 24 * 60, nil
|
||
}
|
||
if startM, err = parseHHMM(fc.ScheduleStart); err != nil {
|
||
return 0, 0, errors.Wrap(err, "parse schedule start")
|
||
}
|
||
if endM, err = parseHHMM(fc.ScheduleEnd); err != nil {
|
||
return 0, 0, errors.Wrap(err, "parse schedule end")
|
||
}
|
||
if endM <= startM {
|
||
return 0, 0, errors.New("schedule end must be after start")
|
||
}
|
||
return startM, endM, nil
|
||
}
|
||
|
||
// scheduleSlotStatus 返回 now 相对循环定时窗口的位置；未启用循环定时时恒为"在窗口内"。
|
||
func (fc *FeatureControl) scheduleSlotStatus(now time.Time) scheduleSlotStatus {
|
||
if !fc.scheduleActive() {
|
||
return scheduleInWindow
|
||
}
|
||
if !fc.scheduleDayOpen(now) {
|
||
return scheduleAfterEnd
|
||
}
|
||
startM, endM, err := fc.scheduleWindow()
|
||
if err != nil {
|
||
return scheduleInWindow // 配置异常按不限制处理（路由层已校验，此处兜底）
|
||
}
|
||
mins := now.Hour()*60 + now.Minute()
|
||
switch {
|
||
case mins < startM:
|
||
return scheduleBeforeStart
|
||
case mins >= endM:
|
||
return scheduleAfterEnd
|
||
}
|
||
return scheduleInWindow
|
||
}
|
||
|
||
// nextOpenAt 计算下一次可开放的时间（严格晚于 now）。
|
||
// 同时考虑一次性窗口与循环定时，返回二者中最早的下一次开放时刻；永久关闭时返回 nil。
|
||
func (fc *FeatureControl) nextOpenAt(now time.Time) *time.Time {
|
||
var earliest *time.Time
|
||
|
||
// 未启用循环定时时，一次性开放时间即为下一次开放。
|
||
// 启用后由下方按日扫描统一处理（一次性开放时间也必须落在循环窗口内）。
|
||
if fc.OpenAt != nil && fc.OpenAt.After(now) && !fc.scheduleActive() {
|
||
t := *fc.OpenAt
|
||
earliest = &t
|
||
}
|
||
|
||
if fc.scheduleActive() {
|
||
startM, endM, err := fc.scheduleWindow()
|
||
if err == nil {
|
||
day := startOfDay(now)
|
||
// 扫描今天起的 8 天：7 天覆盖全部周几组合，多 1 天兜底边界。
|
||
for i := 0; i < 8; i++ {
|
||
d := day.AddDate(0, 0, i)
|
||
if !fc.scheduleDayOpen(d) {
|
||
continue
|
||
}
|
||
slotStart := d.Add(time.Duration(startM) * time.Minute)
|
||
slotEnd := d.Add(time.Duration(endM) * time.Minute)
|
||
// 与一次性窗口求交集：有效开放起点 = max(时段起点, 一次性开放时间)，且须在时段与一次性关闭时间之前
|
||
effStart := slotStart
|
||
if fc.OpenAt != nil && fc.OpenAt.After(effStart) {
|
||
effStart = *fc.OpenAt
|
||
}
|
||
if !effStart.Before(slotEnd) {
|
||
continue // 有效开放起点晚于该日时段结束，该日无有效窗口
|
||
}
|
||
if fc.CloseAt != nil && !effStart.Before(*fc.CloseAt) {
|
||
continue // 有效开放起点已过一次性关闭时间
|
||
}
|
||
if effStart.After(now) {
|
||
if earliest == nil || effStart.Before(*earliest) {
|
||
t := effStart
|
||
earliest = &t
|
||
}
|
||
break // 该日找到最早有效开放点即可（同一日只有一个窗口）
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return earliest
|
||
}
|
||
|
||
// lastCloseAt 计算最近一次关闭的时间（严格早于 now）；从未开放过时返回 nil。
|
||
func (fc *FeatureControl) lastCloseAt(now time.Time) *time.Time {
|
||
var latest *time.Time
|
||
|
||
// 未启用循环定时时，一次性关闭时间即为最近一次关闭。
|
||
// 启用后由下方按日扫描统一处理（与时段结束取较早者）。
|
||
if fc.CloseAt != nil && fc.CloseAt.Before(now) && !fc.scheduleActive() {
|
||
t := *fc.CloseAt
|
||
latest = &t
|
||
}
|
||
|
||
if fc.scheduleActive() {
|
||
startM, endM, err := fc.scheduleWindow()
|
||
if err == nil {
|
||
day := startOfDay(now)
|
||
// 从今天向前扫描 8 天，找最近一次已结束的窗口。
|
||
for i := 0; i < 8; i++ {
|
||
d := day.AddDate(0, 0, -i)
|
||
if !fc.scheduleDayOpen(d) {
|
||
continue
|
||
}
|
||
slotStart := d.Add(time.Duration(startM) * time.Minute)
|
||
slotEnd := d.Add(time.Duration(endM) * time.Minute)
|
||
// 与一次性窗口求交集：有效关闭点 = min(时段结束, 一次性关闭时间)
|
||
effEnd := slotEnd
|
||
if fc.CloseAt != nil && fc.CloseAt.Before(effEnd) {
|
||
effEnd = *fc.CloseAt
|
||
}
|
||
if effEnd.Before(slotStart) {
|
||
continue // 一次性关闭时间早于该日时段起点，该日无有效窗口
|
||
}
|
||
if effEnd.Before(now) {
|
||
if latest == nil || effEnd.After(*latest) {
|
||
t := effEnd
|
||
latest = &t
|
||
}
|
||
break // 已找到最近一次关闭
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return latest
|
||
}
|
||
|
||
// parseHHMM 解析 "HH:MM" 为当天第几分钟。
|
||
func parseHHMM(s string) (int, error) {
|
||
t, err := time.Parse("15:04", s)
|
||
if err != nil {
|
||
return 0, errors.Wrap(err, "parse HH:MM")
|
||
}
|
||
return t.Hour()*60 + t.Minute(), nil
|
||
}
|
||
|
||
// containsWeekday 判断逗号分隔的周几列表（0=周日…6=周六）是否包含 wd。
|
||
func containsWeekday(days string, wd int) bool {
|
||
for _, part := range strings.Split(days, ",") {
|
||
part = strings.TrimSpace(part)
|
||
if part == "" {
|
||
continue
|
||
}
|
||
n, err := strconv.Atoi(part)
|
||
if err == nil && n == wd {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// startOfDay 返回 t 所在日历日的零点（保持时区一致）。
|
||
func startOfDay(t time.Time) time.Time {
|
||
y, m, d := t.Date()
|
||
return time.Date(y, m, d, 0, 0, 0, 0, t.Location())
|
||
}
|
||
|
||
// DefaultFeatureControl 返回某功能的默认配置（尚未落库时的行为）。提问与投票默认开启
|
||
// （与历史行为一致）；私聊默认关闭，沿用 users.allow_chat 默认值，避免历史账号被动开启。
|
||
func DefaultFeatureControl(userID uint, feature string) *FeatureControl {
|
||
return &FeatureControl{
|
||
UserID: userID,
|
||
Feature: feature,
|
||
Enabled: feature != FeatureChat,
|
||
}
|
||
}
|
||
|
||
// FeatureStateOf 读取某用户某功能当前的综合状态。查询失败或无存储时回退默认配置，
|
||
// 保证单个依赖表异常不会让整站功能不可用。
|
||
func FeatureStateOf(ctx context.Context, userID uint, feature string) FeatureState {
|
||
if FeatureControls == nil {
|
||
return DefaultFeatureControl(userID, feature).Evaluate(time.Now())
|
||
}
|
||
fc, err := FeatureControls.Get(ctx, userID, feature)
|
||
if err != nil {
|
||
logrus.WithContext(ctx).WithError(err).Errorf("Failed to get feature control %q of user %d", feature, userID)
|
||
return DefaultFeatureControl(userID, feature).Evaluate(time.Now())
|
||
}
|
||
return fc.Evaluate(time.Now())
|
||
}
|
||
|
||
// FeatureStateOfStrict 与 FeatureStateOf 相同，但查询失败时返回错误而不回退默认配置。
|
||
//
|
||
// 给**写入路径**用。FeatureStateOf 的 fail-open 对读展示是对的（配置表抖动不该让
|
||
// 页面白屏），但对写入是危险的：它回退到 DefaultFeatureControl —— 提问与投票的
|
||
// 默认值是「开启」，于是箱主明明设了「已关闭」或「已达上限」，只要这次读配置失败
|
||
// 就被放行，等于定量收集与功能开关都能被一次数据库抖动绕过去。
|
||
// 与审核链路「不可用即拒绝」同一口径。
|
||
func FeatureStateOfStrict(ctx context.Context, userID uint, feature string) (FeatureState, error) {
|
||
if FeatureControls == nil {
|
||
// 未装配（测试 / 部分初始化）：沿用默认配置，否则所有写路径都会失败。
|
||
return DefaultFeatureControl(userID, feature).Evaluate(time.Now()), nil
|
||
}
|
||
fc, err := FeatureControls.Get(ctx, userID, feature)
|
||
if err != nil {
|
||
logrus.WithContext(ctx).WithError(err).Errorf("Failed to get feature control %q of user %d", feature, userID)
|
||
return FeatureState{}, errors.Wrap(err, "get feature control")
|
||
}
|
||
return fc.Evaluate(time.Now()), nil
|
||
}
|
||
|
||
// FeatureOpen 便捷入口：某用户某功能当前是否可用。
|
||
func FeatureOpen(ctx context.Context, userID uint, feature string) bool {
|
||
return FeatureStateOf(ctx, userID, feature).Open
|
||
}
|
||
|
||
// IsValidFeature 判断功能标识是否合法（防越权写入未知功能）。
|
||
func IsValidFeature(feature string) bool {
|
||
for _, k := range FeatureKeys {
|
||
if k == feature {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func (db *featureControls) Get(ctx context.Context, userID uint, feature string) (*FeatureControl, error) {
|
||
var fc FeatureControl
|
||
err := db.WithContext(ctx).Where("user_id = ? AND feature = ?", userID, feature).First(&fc).Error
|
||
if err != nil {
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
return DefaultFeatureControl(userID, feature), nil
|
||
}
|
||
return nil, errors.Wrap(err, "get feature control")
|
||
}
|
||
return &fc, nil
|
||
}
|
||
|
||
func (db *featureControls) ListByUserID(ctx context.Context, userID uint) ([]*FeatureControl, error) {
|
||
var list []*FeatureControl
|
||
err := db.WithContext(ctx).
|
||
Where("user_id = ?", userID).
|
||
Order("feature ASC").
|
||
Find(&list).Error
|
||
if err != nil {
|
||
return nil, errors.Wrap(err, "list feature controls by user id")
|
||
}
|
||
return list, nil
|
||
}
|
||
|
||
func (db *featureControls) ListByUserIDs(ctx context.Context, userIDs []uint, feature string) (map[uint]*FeatureControl, error) {
|
||
result := make(map[uint]*FeatureControl, len(userIDs))
|
||
if len(userIDs) == 0 {
|
||
return result, nil
|
||
}
|
||
var list []*FeatureControl
|
||
if err := db.WithContext(ctx).
|
||
Where("user_id IN ? AND feature = ?", userIDs, feature).
|
||
Find(&list).Error; err != nil {
|
||
return nil, errors.Wrap(err, "list feature controls by user ids")
|
||
}
|
||
for _, fc := range list {
|
||
result[fc.UserID] = fc
|
||
}
|
||
return result, nil
|
||
}
|
||
|
||
type UpdateFeatureControlOptions struct {
|
||
Enabled bool
|
||
OpenAt *time.Time
|
||
CloseAt *time.Time
|
||
ScheduleDays string
|
||
ScheduleStart string
|
||
ScheduleEnd string
|
||
QuotaLimit int64
|
||
}
|
||
|
||
// Save 写入功能配置。用 ON CONFLICT 幂等写入并显式列出更新列，
|
||
// 避免把 quota_count（已收集数量）误重置为 0。
|
||
func (db *featureControls) Save(ctx context.Context, userID uint, feature string, opts UpdateFeatureControlOptions) error {
|
||
now := time.Now()
|
||
fc := &FeatureControl{
|
||
// UpdatedAt 显式写入（gorm 的 on-conflict 更新列会用到）；CreatedAt 留零值由 gorm 自动填充
|
||
Model: dbutil.Model{UpdatedAt: now},
|
||
UserID: userID,
|
||
Feature: feature,
|
||
Enabled: opts.Enabled,
|
||
OpenAt: opts.OpenAt,
|
||
CloseAt: opts.CloseAt,
|
||
ScheduleDays: opts.ScheduleDays,
|
||
ScheduleStart: opts.ScheduleStart,
|
||
ScheduleEnd: opts.ScheduleEnd,
|
||
QuotaLimit: opts.QuotaLimit,
|
||
}
|
||
err := db.WithContext(ctx).Clauses(clause.OnConflict{
|
||
Columns: []clause.Column{{Name: "user_id"}, {Name: "feature"}},
|
||
DoUpdates: clause.AssignmentColumns([]string{
|
||
"enabled", "open_at", "close_at",
|
||
"schedule_days", "schedule_start", "schedule_end",
|
||
"quota_limit", "updated_at",
|
||
}),
|
||
}).Create(fc).Error
|
||
if err != nil {
|
||
return errors.Wrap(err, "save feature control")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// ResetQuota 清零收集计数并记录重置时间。无记录时创建一条（沿用该功能的默认开关值）。
|
||
func (db *featureControls) ResetQuota(ctx context.Context, userID uint, feature string) error {
|
||
now := time.Now()
|
||
res := db.WithContext(ctx).Model(&FeatureControl{}).
|
||
Where("user_id = ? AND feature = ?", userID, feature).
|
||
Updates(map[string]interface{}{
|
||
"quota_count": 0,
|
||
"quota_reset_at": now,
|
||
"updated_at": now,
|
||
})
|
||
if res.Error != nil {
|
||
return errors.Wrap(res.Error, "reset feature quota")
|
||
}
|
||
if res.RowsAffected > 0 {
|
||
return nil
|
||
}
|
||
// 尚无记录：按默认配置创建（提问/投票默认开启，私聊默认关闭）
|
||
fc := DefaultFeatureControl(userID, feature)
|
||
fc.QuotaResetAt = &now
|
||
if err := db.WithContext(ctx).
|
||
Clauses(clause.OnConflict{DoNothing: true}).
|
||
Create(fc).Error; err != nil {
|
||
return errors.Wrap(err, "create feature control on reset quota")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// IncrementQuota 累加收集计数（delta 可为负，用于删除内容时回退计数）。
|
||
// 负 delta 不会把计数减到 0 以下（WHERE quota_count > 0），避免误删历史内容导致负计数。
|
||
func (db *featureControls) IncrementQuota(ctx context.Context, userID uint, feature string, delta int64) error {
|
||
return incrementQuotaTx(db.WithContext(ctx), userID, feature, delta)
|
||
}
|
||
|
||
// incrementQuotaTx 是配额递增的唯一实现，接受任意 *gorm.DB（可以是事务）。
|
||
//
|
||
// 为什么要暴露一个「能用事务」的版本：配额与内容必须是同生共死的关系。
|
||
// 原来「创建提问」与「quota_count+1」是两次独立写入，后者失败只打一条 Warn ——
|
||
// 于是计数比真实行数少，箱主的「已收集 7/10」永远偏低，达到上限后仍能继续收，
|
||
// 而重置计数也校准不回来（重置是把计数清零，与实际行数更脱节）。
|
||
// 现在内容 store 把这一步放进自己的事务里，任一步失败整体回滚，计数天然对齐。
|
||
func reserveFeatureQuotaTx(tx *gorm.DB, userID uint, feature string) error {
|
||
if err := tx.Clauses(clause.OnConflict{DoNothing: true}).Create(DefaultFeatureControl(userID, feature)).Error; err != nil {
|
||
return errors.Wrap(err, "initialize feature quota")
|
||
}
|
||
var fc FeatureControl
|
||
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
|
||
Where("user_id = ? AND feature = ?", userID, feature).First(&fc).Error; err != nil {
|
||
return errors.Wrap(err, "lock feature quota")
|
||
}
|
||
if fc.QuotaLimit > 0 && fc.QuotaCount >= fc.QuotaLimit {
|
||
return ErrFeatureQuotaReached
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func incrementQuotaTx(tx *gorm.DB, userID uint, feature string, delta int64) error {
|
||
if delta == 0 {
|
||
return nil
|
||
}
|
||
now := time.Now()
|
||
q := tx.Model(&FeatureControl{}).
|
||
Where("user_id = ? AND feature = ?", userID, feature)
|
||
if delta < 0 {
|
||
q = q.Where("quota_count > 0")
|
||
}
|
||
res := q.Updates(map[string]interface{}{
|
||
"quota_count": gorm.Expr("quota_count + ?", delta),
|
||
"updated_at": now,
|
||
})
|
||
if res.Error != nil {
|
||
return errors.Wrap(res.Error, "increment feature quota")
|
||
}
|
||
if res.RowsAffected > 0 {
|
||
return nil
|
||
}
|
||
|
||
// 尚无配置行：建一条并把计数初始化为本条（负数按 0 起步，不产生负计数）。
|
||
fc := DefaultFeatureControl(userID, feature)
|
||
if delta > 0 {
|
||
fc.QuotaCount = delta
|
||
}
|
||
fc.QuotaResetAt = &now
|
||
created := tx.
|
||
Clauses(clause.OnConflict{DoNothing: true}).
|
||
Create(fc)
|
||
if created.Error != nil {
|
||
return errors.Wrap(created.Error, "create feature control on increment quota")
|
||
}
|
||
if created.RowsAffected > 0 || delta <= 0 {
|
||
return nil
|
||
}
|
||
// 并发下配置行可能刚被其它请求创建：补一次累加，保证计数不丢。
|
||
retry := tx.Model(&FeatureControl{}).
|
||
Where("user_id = ? AND feature = ?", userID, feature).
|
||
Updates(map[string]interface{}{
|
||
"quota_count": gorm.Expr("quota_count + ?", delta),
|
||
"updated_at": time.Now(),
|
||
})
|
||
if retry.Error != nil {
|
||
return errors.Wrap(retry.Error, "increment feature quota (retry)")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// backfillFeatureControls 为尚未初始化的历史账号补齐功能配置行。
|
||
//
|
||
// 私聊开关此前落在 users.allow_chat，提问/投票一直默认开启；功能上线后没有配置行时
|
||
// Get 会回退默认值（私聊默认关闭），导致已开启私聊的历史账号被静默关闭，
|
||
// 故在 AutoMigrate 之后按 users.allow_chat 回填私聊，其余按「开启」回填。
|
||
//
|
||
// 幂等：每轮只挑仍缺行的账号，分批 + ON CONFLICT DO NOTHING，避免不同数据库上
|
||
// 「边插入边查同一张表」的差异行为，也保证多实例并发启动时不重复插入。
|
||
func backfillFeatureControls(db *gorm.DB) error {
|
||
// backfillBatchSize 每轮处理的账号数，控制单次事务体积与内存占用。
|
||
const backfillBatchSize = 500
|
||
|
||
type backfillRow struct {
|
||
UserID uint
|
||
AllowChat bool
|
||
}
|
||
|
||
for _, feature := range FeatureKeys {
|
||
defaultEnabled := feature != FeatureChat
|
||
created := int64(0)
|
||
|
||
for {
|
||
var rows []backfillRow
|
||
err := db.Table("users").
|
||
Select("users.id AS user_id, users.allow_chat AS allow_chat").
|
||
Joins("LEFT JOIN feature_controls fc ON fc.user_id = users.id AND fc.feature = ?", feature).
|
||
Where("users.deleted_at IS NULL AND fc.id IS NULL").
|
||
Limit(backfillBatchSize).
|
||
Scan(&rows).Error
|
||
if err != nil {
|
||
return errors.Wrapf(err, "query users without feature control %s", feature)
|
||
}
|
||
if len(rows) == 0 {
|
||
break
|
||
}
|
||
|
||
batch := make([]FeatureControl, 0, len(rows))
|
||
for _, r := range rows {
|
||
enabled := defaultEnabled
|
||
if feature == FeatureChat {
|
||
enabled = r.AllowChat
|
||
}
|
||
batch = append(batch, FeatureControl{
|
||
UserID: r.UserID,
|
||
Feature: feature,
|
||
Enabled: enabled,
|
||
})
|
||
}
|
||
|
||
res := db.Clauses(clause.OnConflict{DoNothing: true}).Create(&batch)
|
||
if res.Error != nil {
|
||
return errors.Wrapf(res.Error, "backfill feature controls: %s", feature)
|
||
}
|
||
// 本轮没有任何新行落库：说明并发实例已写完或数据异常，停止循环避免死循环。
|
||
if res.RowsAffected == 0 {
|
||
break
|
||
}
|
||
created += res.RowsAffected
|
||
if len(rows) < backfillBatchSize {
|
||
break
|
||
}
|
||
}
|
||
|
||
if created > 0 {
|
||
logrus.WithField("feature", feature).
|
||
Infof("功能开关初始化：为 %d 个历史账号补齐配置", created)
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// reconcileLegacyChatEnabled 修复旧版 backfill 写入的私聊错误开关。
|
||
//
|
||
// 背景：早期 Enabled 带 gorm:"default:true"，backfill 为 allow_chat=false 的用户补行时
|
||
// false 被替换为 true，私聊被被动开启；UpdateChatSettings 还会把 allow_chat 同步为 true。
|
||
//
|
||
// 纠偏条件（必须同时满足，只命中「纯 backfill 默认行」，绝不碰箱主配置过的行）：
|
||
// feature='chat' 且 enabled=true；对应 users.allow_chat=false；该行无任何自定义配置
|
||
// （open_at/close_at 为空、quota_limit=0、循环定时为空）；updated_at <= created_at。
|
||
// 满足即复位 enabled=false 并同步 users.allow_chat=false。幂等，已配置行不会重复命中。
|
||
func reconcileLegacyChatEnabled(db *gorm.DB) error {
|
||
// reconcileBatchSize 每轮处理的账号数，控制单次事务体积。
|
||
const reconcileBatchSize = 500
|
||
|
||
// 两者只匹配纯默认配置的私聊行（无一次性窗口/循环定时/定量上限），仅列前缀不同：
|
||
// FC 版带 "fc." 用于 SELECT；纯版不带前缀用于 UPDATE（GORM 不会为 UPDATE 自动加别名，
|
||
// 带前缀会报 missing FROM-clause entry for table "fc"）。同时兼容旧行 NULL 与新行空串。
|
||
pureDefaultFilterFC := "fc.open_at IS NULL AND fc.close_at IS NULL AND fc.quota_limit = 0" +
|
||
" AND (fc.schedule_days IS NULL OR fc.schedule_days = '')" +
|
||
" AND (fc.schedule_start IS NULL OR fc.schedule_start = '')" +
|
||
" AND (fc.schedule_end IS NULL OR fc.schedule_end = '')"
|
||
pureDefaultFilterPlain := "open_at IS NULL AND close_at IS NULL AND quota_limit = 0" +
|
||
" AND (schedule_days IS NULL OR schedule_days = '')" +
|
||
" AND (schedule_start IS NULL OR schedule_start = '')" +
|
||
" AND (schedule_end IS NULL OR schedule_end = '')"
|
||
|
||
fixed := int64(0)
|
||
for {
|
||
var rows []struct{ UserID uint }
|
||
err := db.Table("feature_controls fc").
|
||
Select("fc.user_id").
|
||
Joins("JOIN users u ON u.id = fc.user_id AND u.allow_chat = false").
|
||
Where("fc.feature = ? AND fc.enabled = true", FeatureChat).
|
||
Where(pureDefaultFilterFC).
|
||
Where("fc.updated_at <= fc.created_at").
|
||
Where("fc.deleted_at IS NULL AND u.deleted_at IS NULL").
|
||
Limit(reconcileBatchSize).
|
||
Scan(&rows).Error
|
||
if err != nil {
|
||
return errors.Wrap(err, "query legacy chat rows to reconcile")
|
||
}
|
||
if len(rows) == 0 {
|
||
break
|
||
}
|
||
|
||
userIDs := make([]uint, 0, len(rows))
|
||
for _, r := range rows {
|
||
userIDs = append(userIDs, r.UserID)
|
||
}
|
||
|
||
// 复位 feature_controls.enabled（同一批用户 + 同样的纯默认条件，避免误伤并发新增配置）。
|
||
res := db.Table("feature_controls").
|
||
Where("user_id IN ? AND feature = ? AND enabled = true", userIDs, FeatureChat).
|
||
Where(pureDefaultFilterPlain).
|
||
Where("deleted_at IS NULL").
|
||
Update("enabled", false)
|
||
if res.Error != nil {
|
||
return errors.Wrap(res.Error, "reset legacy chat enabled")
|
||
}
|
||
fixed += res.RowsAffected
|
||
|
||
// 同步 users.allow_chat，保证两处一致。
|
||
if err := db.Table("users").
|
||
Where("id IN ? AND allow_chat = true", userIDs).
|
||
Where("deleted_at IS NULL").
|
||
Update("allow_chat", false).Error; err != nil {
|
||
return errors.Wrap(err, "sync legacy users.allow_chat")
|
||
}
|
||
|
||
if int64(len(rows)) < reconcileBatchSize {
|
||
break
|
||
}
|
||
}
|
||
|
||
if fixed > 0 {
|
||
logrus.WithField("count", fixed).
|
||
Warn("私聊开关纠偏：旧版数据把未开启私聊的账号置为开启，已复位为关闭")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// normalizeChatQuota 清零私聊行上历史残留的收集上限与计数。
|
||
// 私聊不提供收集上限（会话是双向对话，限制「新建会话数」意义不大），UI 已隐藏该字段、
|
||
// 保存时强制清零；此处在启动期兜底清零，避免达到残留上限后私聊「莫名关闭」。
|
||
// 幂等，失败由调用方告警（不阻断启动）。
|
||
func normalizeChatQuota(db *gorm.DB) error {
|
||
res := db.Model(&FeatureControl{}).
|
||
Where("feature = ? AND (quota_limit > 0 OR quota_count > 0)", FeatureChat).
|
||
Updates(map[string]interface{}{"quota_limit": 0, "quota_count": 0})
|
||
if res.Error != nil {
|
||
return errors.Wrap(res.Error, "normalize chat feature quota")
|
||
}
|
||
if res.RowsAffected > 0 {
|
||
logrus.WithField("count", res.RowsAffected).
|
||
Info("私聊收集上限已下线：已清零历史残留的私聊收集上限与计数")
|
||
}
|
||
return nil
|
||
}
|