feat(channels): 渠道管理 - 可视化排序与别名并修复注册及外观清理 (#444)

This commit is contained in:
Ray authored and GitHub committed 2026-09-08 20:56:42 +08:00
1 parent 381edf37e3
commit 8360b2c933
41 files changed
+1485 -148

No files matched your search

@@ -0,0 +1,42 @@
package database
import "testing"
func TestChannelPresentationMigrationPreservesExistingRows(t *testing.T) {
db, err := Open(Config{Driver: "sqlite", DSN: "file:channel-presentation-migration?mode=memory&cache=shared"})
if err != nil {
t.Fatal(err)
}
for _, sql := range []string{
`CREATE TABLE model_channels (id TEXT PRIMARY KEY, name TEXT, api_key TEXT)`,
`CREATE TABLE channel_models (id TEXT PRIMARY KEY, price_version INTEGER, unit_price_microcredits INTEGER)`,
`INSERT INTO model_channels VALUES ('existing', '原渠道', 'synthetic-key')`,
`INSERT INTO channel_models VALUES ('existing', 7, 12345)`,
} {
if err := db.Exec(sql).Error; err != nil {
t.Fatal(err)
}
}
for i := 0; i < 2; i++ {
if err := migrateChannelPresentation(db); err != nil {
t.Fatal(err)
}
}
var channel struct {
Name, APIKey, PublicAlias string
SortOrder int
}
if err := db.Table("model_channels").First(&channel).Error; err != nil {
t.Fatal(err)
}
if channel.Name != "原渠道" || channel.APIKey != "synthetic-key" || channel.PublicAlias != "" || channel.SortOrder != 0 {
t.Fatalf("channel migration: %#v", channel)
}
var cm struct{ PriceVersion, UnitPriceMicrocredits, SortOrder int }
if err := db.Table("channel_models").First(&cm).Error; err != nil {
t.Fatal(err)
}
if cm.PriceVersion != 7 || cm.UnitPriceMicrocredits != 12345 || cm.SortOrder != 0 {
t.Fatalf("model migration: %#v", cm)
}
}
+16 -1
View File
@@ -10,7 +10,7 @@ import (
"gorm.io/gorm"
)
const CurrentSchemaVersion int64 = 8
const CurrentSchemaVersion int64 = 9
const baselineSchemaChecksum = "sha256:open-ai-canvas-schema-v1-20260830"
const schemaMigrationAppliedAtIndexChecksum = "sha256:schema-migrations-applied-at-index-v2-20260830"
@@ -54,6 +54,21 @@ var schemaMigrations = []migration{
{version: 6, name: "resource_playback_variant", checksum: resourcePlaybackChecksum, apply: migrateSchemaV6},
{version: 7, name: "asset_library_folders", checksum: assetLibraryFoldersChecksum, apply: migrateSchemaV7},
{version: 8, name: "logical_model_active_code", checksum: logicalModelActiveCodeChecksum, apply: migrateSchemaV8},
{version: 9, name: "channel_presentation", checksum: "sha256:channel-presentation-v9-20260908", apply: migrateChannelPresentation},
}
func migrateChannelPresentation(tx *gorm.DB) error {
for _, column := range []struct {
model any
field string
}{{&model.ModelChannel{}, "PublicAlias"}, {&model.ModelChannel{}, "SortOrder"}, {&model.ChannelModel{}, "SortOrder"}} {
if !tx.Migrator().HasColumn(column.model, column.field) {
if err := tx.Migrator().AddColumn(column.model, column.field); err != nil {
return err
}
}
}
return nil
}
func migrationsForDatabase(db *gorm.DB) ([]migration, error) {
+4 -1
View File
@@ -122,6 +122,9 @@ func TestMigrateSchemaV4AddsResourceUploadKeyToExistingSchema(t *testing.T) {
if err := db.Exec(`CREATE TABLE resources (id TEXT PRIMARY KEY, user_id TEXT NOT NULL)`).Error; err != nil {
t.Fatal(err)
}
if err := db.AutoMigrate(&model.ModelChannel{}, &model.ChannelModel{}); err != nil {
t.Fatal(err)
}
if err := db.AutoMigrate(&schemaMigration{}); err != nil {
t.Fatal(err)
}
@@ -163,7 +166,7 @@ func TestMigrateSchemaRepairsLegacyAssetFoldersMigrationOrder(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if err := db.AutoMigrate(&model.Resource{}, &model.Asset{}, &model.AssetFolder{}); err != nil {
if err := db.AutoMigrate(&model.Resource{}, &model.Asset{}, &model.AssetFolder{}, &model.ModelChannel{}, &model.ChannelModel{}); err != nil {
t.Fatal(err)
}
if err := db.AutoMigrate(&schemaMigration{}); err != nil {
+4
View File
@@ -21,6 +21,7 @@ import (
)
func RegisterAuthRoutes(r *gin.RouterGroup, svc *service.Service) {
registerChannelOrderRoutes(r, svc)
r.GET("/auth/settings", func(c *gin.Context) {
settings, err := svc.PublicAuthSettings()
if err != nil {
@@ -61,6 +62,9 @@ func RegisterAuthRoutes(r *gin.RouterGroup, svc *service.Service) {
if !available || !enforceRateLimit(c, "email-code:"+c.ClientIP(), policy.Request.EmailCodePerHour, time.Hour) {
return
}
if !enforceRateLimit(c, "registration-email-account:"+passwordResetRateLimitSubject(req.Email), 10, time.Hour) {
return
}
if err := svc.SendRegistrationEmailCode(req.Email); err != nil {
failService(c, err)
return
+43
View File
@@ -0,0 +1,43 @@
package handler
import (
"github.com/gin-gonic/gin"
"infinite-canvas/backend/internal/service"
"net/http"
)
func registerChannelOrderRoutes(r *gin.RouterGroup, svc *service.Service) {
for _, path := range []string{"/admin/channels/order", "/admin/channels/:id/models/order"} {
r.GET(path, func(c *gin.Context) {
user, err := currentUser(c, svc)
if err != nil {
failService(c, err)
return
}
items, err := svc.AdminChannelOrder(user, c.Param("id"))
if err != nil {
failService(c, err)
return
}
ok(c, gin.H{"items": items})
})
r.PUT(path, func(c *gin.Context) {
user, err := currentUser(c, svc)
if err != nil {
failService(c, err)
return
}
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, 1<<20)
var req service.ChannelOrderRequest
if err := c.ShouldBindJSON(&req); err != nil {
fail(c, http.StatusBadRequest, err)
return
}
if err := svc.SaveAdminChannelOrder(user, c.Param("id"), req); err != nil {
failService(c, err)
return
}
ok(c, gin.H{"saved": true})
})
}
}
+17
View File
@@ -293,6 +293,23 @@ func RegisterFinanceRoutes(r *gin.RouterGroup, svc *service.Service) {
r.PATCH("/admin/channels/:id/models/:modelId", func(c *gin.Context) {
saveChannelModel(c, svc, c.Param("modelId"))
})
r.PATCH("/admin/channels/:id/models/:modelId/sort", func(c *gin.Context) {
user, err := currentUser(c, svc)
if err != nil {
failService(c, err)
return
}
var req service.ChannelModelSortRequest
if err := c.ShouldBindJSON(&req); err != nil {
fail(c, http.StatusBadRequest, err)
return
}
if err := svc.UpdateAdminChannelModelSort(user, c.Param("id"), c.Param("modelId"), req); err != nil {
failService(c, err)
return
}
ok(c, gin.H{"updated": true})
})
r.DELETE("/admin/channels/:id/models/:modelId", func(c *gin.Context) {
user, err := currentUser(c, svc)
if err != nil {
+7
View File
@@ -4,6 +4,7 @@ import (
"errors"
"log"
"net/http"
"strconv"
"strings"
"infinite-canvas/backend/internal/service"
@@ -27,6 +28,12 @@ func fail(c *gin.Context, status int, err error) {
}
func failService(c *gin.Context, err error) {
var cooldown *service.EmailCodeCooldownError
if errors.As(err, &cooldown) {
c.Header("Retry-After", strconv.Itoa(cooldown.Seconds))
fail(c, http.StatusTooManyRequests, cooldown)
return
}
var appErr *service.AppError
if errors.As(err, &appErr) && validErrorStatus(appErr.Status) {
code := appErr.Code
@@ -18,6 +18,15 @@ type failureEnvelope struct {
Msg string `json:"msg"`
}
func TestFailServiceRegistrationCooldown(t *testing.T) {
recorder, context := responseTestContext()
failService(context, &service.EmailCodeCooldownError{Seconds: 47})
response := decodeFailureEnvelope(t, recorder)
if recorder.Code != http.StatusTooManyRequests || response.Code != 429 || recorder.Header().Get("Retry-After") != "47" || !strings.Contains(response.Msg, "47") {
t.Fatalf("cooldown response: status=%d header=%s body=%#v", recorder.Code, recorder.Header().Get("Retry-After"), response)
}
}
func TestFailServiceProjectsAppError(t *testing.T) {
recorder, context := responseTestContext()
err := service.NewAppError(http.StatusTooManyRequests, "请求过于频繁,请稍后重试")
+4 -2
View File
@@ -152,8 +152,10 @@ func enforceRateLimit(c *gin.Context, key string, limit int, window time.Duratio
if allowed {
return true
}
c.Header("Retry-After", "60")
fail(c, http.StatusTooManyRequests, errors.New("请求过于频繁,请稍后再试"))
wait := runtimeService.RequestRetryAfter(c.Request.Context(), key, window)
seconds := max(1, int((wait+time.Second-1)/time.Second))
c.Header("Retry-After", strconv.Itoa(seconds))
fail(c, http.StatusTooManyRequests, fmt.Errorf("请求次数已达上限,请在 %d 秒后重试", seconds))
return false
}
+13 -1
View File
@@ -1,8 +1,10 @@
package model
import (
"gorm.io/gorm"
"strings"
"time"
"gorm.io/gorm"
)
type ModelChannel struct {
@@ -11,6 +13,8 @@ type ModelChannel struct {
Scope ChannelScope `json:"scope" gorm:"index;size:24"`
Enabled bool `json:"enabled" gorm:"index"`
Name string `json:"name" gorm:"size:80"`
PublicAlias string `json:"publicAlias" gorm:"size:80;not null;default:''"`
SortOrder int `json:"sortOrder" gorm:"not null;default:0"`
BaseURL string `json:"baseUrl"`
AllowLocalChannel bool `json:"allowLocalChannel" gorm:"default:false"`
APIKey string `json:"-"`
@@ -26,12 +30,20 @@ type ModelChannel struct {
DeletedAt gorm.DeletedAt `json:"-" gorm:"index"`
}
func (channel ModelChannel) PublicName() string {
if alias := strings.TrimSpace(channel.PublicAlias); alias != "" {
return alias
}
return channel.Name
}
type ChannelModel struct {
ID string `json:"id" gorm:"primaryKey;size:36"`
ChannelID string `json:"channelId" gorm:"size:36;index;uniqueIndex:idx_channel_model_key_active,priority:1,where:deleted_at IS NULL"`
ModelKey string `json:"modelKey" gorm:"size:120;uniqueIndex:idx_channel_model_key_active,priority:2,where:deleted_at IS NULL"`
ProviderModelKey string `json:"providerModelKey" gorm:"size:120"`
DisplayName string `json:"displayName" gorm:"size:160"`
SortOrder int `json:"sortOrder" gorm:"not null;default:0"`
Icon string `json:"icon" gorm:"size:80"`
Capability string `json:"capability" gorm:"size:32;index"`
Protocol ChannelInterfaceType `json:"protocol" gorm:"size:32;index"`
@@ -0,0 +1,62 @@
package repository
import (
"errors"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"infinite-canvas/backend/internal/model"
"slices"
"time"
)
var ErrChannelOrderChanged = errors.New("列表已发生变化,请重新打开排序后再保存")
// 全量顺序在事务中保存;拒绝过期快照,避免覆盖另一管理员的调整。
func (r *Repository) SaveChannelOrder(channelID string, ids, expected []string) error {
return r.db.Transaction(func(tx *gorm.DB) error {
var current []string
var target any = &model.ModelChannel{}
query := tx.Model(target).Where("scope = ?", model.ChannelScopeSystem)
if channelID != "" {
if err := r.lockSystemChannelForModelMutation(tx, channelID); err != nil {
return err
}
target = &model.ChannelModel{}
query = tx.Model(target).Where("channel_id = ?", channelID)
}
if tx.Dialector.Name() == "postgres" {
// Lock in a stable order, then read a fresh ordered snapshot after waiting.
// PostgreSQL can otherwise return pre-wait ORDER BY results after another sort commits.
var locked []string
if err := query.Session(&gorm.Session{}).Clauses(clause.Locking{Strength: "UPDATE"}).Order("id asc").Pluck("id", &locked).Error; err != nil {
return err
}
}
if err := query.Order("sort_order asc, created_at asc, id asc").Pluck("id", &current).Error; err != nil {
return err
}
if !slices.Equal(current, expected) || len(ids) != len(current) {
return ErrChannelOrderChanged
}
allowed := make(map[string]bool, len(current))
for _, id := range current {
allowed[id] = true
}
for _, id := range ids {
if !allowed[id] {
return ErrChannelOrderChanged
}
delete(allowed, id)
}
now := time.Now()
for index, id := range ids {
if err := tx.Model(target).Where("id = ?", id).Updates(map[string]any{"sort_order": index, "updated_at": now}).Error; err != nil {
return err
}
}
if channelID != "" {
return refreshChannelModelNames(tx, channelID, now)
}
return nil
})
}
@@ -0,0 +1,45 @@
package repository
import (
"time"
"infinite-canvas/backend/internal/model"
"gorm.io/gorm"
)
func (r *Repository) UpdateSystemChannelPresentation(channelID string, alias *string, sortOrder *int, now time.Time) error {
updates := map[string]any{"updated_at": now}
if alias != nil {
updates["public_alias"] = *alias
}
if sortOrder != nil {
updates["sort_order"] = *sortOrder
}
result := r.db.Model(&model.ModelChannel{}).Where("id = ? AND scope = ?", channelID, model.ChannelScopeSystem).Updates(updates)
if result.Error != nil {
return result.Error
}
if result.RowsAffected == 0 {
return gorm.ErrRecordNotFound
}
return nil
}
// 排序是展示配置,不重写价格、能力版本或模型标识。
func (r *Repository) UpdateChannelModelSort(channelID, modelID string, sortOrder int, now time.Time) error {
return r.db.Transaction(func(tx *gorm.DB) error {
if err := r.lockSystemChannelForModelMutation(tx, channelID); err != nil {
return err
}
result := tx.Model(&model.ChannelModel{}).Where("channel_id = ? AND id = ?", channelID, modelID).
Updates(map[string]any{"sort_order": sortOrder, "updated_at": now})
if result.Error != nil {
return result.Error
}
if result.RowsAffected == 0 {
return gorm.ErrRecordNotFound
}
return refreshChannelModelNames(tx, channelID, now)
})
}
+2 -2
View File
@@ -70,7 +70,7 @@ type AdminRedeemCodeRow struct {
func (r *Repository) ChannelModels(channelID string, includeDisabled bool) ([]model.ChannelModel, error) {
var items []model.ChannelModel
query := r.db.Where("channel_id = ?", channelID).Order("created_at asc")
query := r.db.Where("channel_id = ?", channelID).Order("sort_order asc, created_at asc, id asc")
if !includeDisabled {
query = query.Where("enabled = ?", true)
}
@@ -329,7 +329,7 @@ func refreshChannelModelNames(tx *gorm.DB, channelID string, now time.Time) erro
var names []string
if err := tx.Model(&model.ChannelModel{}).
Where("channel_id = ? AND enabled = ?", channelID, true).
Order("created_at asc").
Order("sort_order asc, created_at asc, id asc").
Pluck("model_key", &names).Error; err != nil {
return err
}
+3 -3
View File
@@ -755,7 +755,7 @@ func (r *Repository) TaskLogs(userID string, taskID string) ([]model.TaskLog, er
func (r *Repository) SystemChannels(includeDisabled bool) ([]model.ModelChannel, error) {
var channels []model.ModelChannel
query := r.db.Order("created_at asc").Where("scope = ?", model.ChannelScopeSystem)
query := r.db.Order("sort_order asc, created_at asc, id asc").Where("scope = ?", model.ChannelScopeSystem)
if !includeDisabled {
query = query.Where("enabled = ?", true)
}
@@ -775,7 +775,7 @@ func (r *Repository) AdminSystemChannels(keyword string, status string, limit in
query := r.db.Model(&model.ModelChannel{}).Where("scope = ?", model.ChannelScopeSystem)
if value := strings.TrimSpace(keyword); value != "" {
pattern := "%" + strings.ToLower(value) + "%"
query = query.Where("lower(name) LIKE ? OR lower(base_url) LIKE ?", pattern, pattern)
query = query.Where("lower(name) LIKE ? OR lower(public_alias) LIKE ? OR lower(base_url) LIKE ?", pattern, pattern, pattern)
}
if status == "enabled" {
query = query.Where("enabled = ?", true)
@@ -785,7 +785,7 @@ func (r *Repository) AdminSystemChannels(keyword string, status string, limit in
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
if err := query.Order("created_at desc").Limit(limit).Offset(offset).Find(&channels).Error; err != nil {
if err := query.Order("sort_order asc, created_at asc, id asc").Limit(limit).Offset(offset).Find(&channels).Error; err != nil {
return nil, 0, err
}
return channels, total, nil
+32 -3
View File
@@ -86,6 +86,8 @@ type AdminReferenceData struct {
type ChannelRequest struct {
Name string `json:"name"`
PublicAlias *string `json:"publicAlias"`
SortOrder *int `json:"sortOrder"`
BaseURL string `json:"baseUrl"`
AllowLocalChannel *bool `json:"allowLocalChannel"`
APIKey string `json:"apiKey"`
@@ -103,6 +105,8 @@ type PublicModelChannel struct {
Scope model.ChannelScope `json:"scope"`
Enabled bool `json:"enabled"`
Name string `json:"name"`
PublicAlias string `json:"publicAlias,omitempty"`
SortOrder int `json:"sortOrder"`
BaseURL string `json:"baseUrl"`
AllowLocalChannel bool `json:"allowLocalChannel,omitempty"`
APIKey string `json:"apiKey"`
@@ -539,6 +543,10 @@ func (s *Service) UpdateSystemChannel(actor *model.User, id string, req ChannelR
if err := s.RequireAdmin(actor); err != nil {
return nil, err
}
if req.presentationOnly() {
return s.updateChannelPresentation(id, req)
}
updateModels := req.Models != nil
channel, err := s.repo.AdminSystemChannel(id)
if err != nil {
return nil, err
@@ -567,8 +575,10 @@ func (s *Service) UpdateSystemChannel(actor *model.User, id string, req ChannelR
if err := s.repo.Save(&next); err != nil {
return nil, err
}
if err := s.syncInitialChannelModels(&next, req.Models); err != nil {
return nil, err
if updateModels {
if err := s.syncInitialChannelModels(&next, req.Models); err != nil {
return nil, err
}
}
s.invalidateRouteCatalog()
items, err := s.repo.ChannelModels(next.ID, true)
@@ -779,6 +789,19 @@ func (s *Service) channelFromRequest(req ChannelRequest, channel model.ModelChan
return channel, err
}
channel.Name = name
if req.PublicAlias != nil {
alias := strings.TrimSpace(*req.PublicAlias)
if len([]rune(alias)) > 80 {
return channel, BadAuthRequest("前台显示别名不能超过 80 个字符")
}
channel.PublicAlias = alias
}
if req.SortOrder != nil {
if err := validateChannelSortOrder(*req.SortOrder); err != nil {
return channel, err
}
channel.SortOrder = *req.SortOrder
}
channel.BaseURL = strings.TrimRight(baseURL, "/")
channel.AllowLocalChannel = requestedAllowLocal
if req.APIKey != "" {
@@ -862,12 +885,18 @@ func publicChannel(channel model.ModelChannel, admin bool, channelModels []model
} else if admin {
apiKey = channel.APIKey
}
name, alias := channel.PublicName(), ""
if admin {
name, alias = channel.Name, channel.PublicAlias
}
return PublicModelChannel{
ID: channel.ID,
UserID: channel.UserID,
Scope: channel.Scope,
Enabled: channel.Enabled,
Name: channel.Name,
Name: name,
PublicAlias: alias,
SortOrder: channel.SortOrder,
BaseURL: baseURL,
AllowLocalChannel: admin && channel.AllowLocalChannel,
APIKey: apiKey,
+63
View File
@@ -0,0 +1,63 @@
package service
import (
"errors"
"infinite-canvas/backend/internal/model"
"infinite-canvas/backend/internal/repository"
"net/http"
)
type ChannelOrderItem struct {
ID string `json:"id"`
Name string `json:"name"`
Enabled bool `json:"enabled"`
}
type ChannelOrderRequest struct {
IDs []string `json:"ids"`
ExpectedIDs []string `json:"expectedIds"`
}
func (s *Service) AdminChannelOrder(actor *model.User, channelID string) ([]ChannelOrderItem, error) {
if err := s.RequireAdmin(actor); err != nil {
return nil, err
}
result := []ChannelOrderItem{}
if channelID == "" {
rows, err := s.repo.SystemChannels(true)
if err != nil {
return nil, err
}
for _, row := range rows {
result = append(result, ChannelOrderItem{row.ID, row.Name, row.Enabled})
}
} else {
if _, err := s.repo.AdminSystemChannel(channelID); err != nil {
return nil, err
}
rows, err := s.repo.ChannelModels(channelID, true)
if err != nil {
return nil, err
}
for _, row := range rows {
result = append(result, ChannelOrderItem{row.ID, firstNonEmpty(row.DisplayName, row.ModelKey), row.Enabled})
}
}
return result, nil
}
func (s *Service) SaveAdminChannelOrder(actor *model.User, channelID string, req ChannelOrderRequest) error {
if err := s.RequireAdmin(actor); err != nil {
return err
}
if req.IDs == nil || req.ExpectedIDs == nil || len(req.IDs) > 10000 {
return BadAuthRequest("请重新加载完整排序列表")
}
err := s.repo.SaveChannelOrder(channelID, req.IDs, req.ExpectedIDs)
if errors.Is(err, repository.ErrChannelOrderChanged) {
return NewAppError(http.StatusConflict, err.Error())
}
if err == nil {
s.invalidateRouteCatalog()
}
return err
}
@@ -0,0 +1,62 @@
package service
import (
"infinite-canvas/backend/internal/model"
"testing"
)
func TestVisualChannelOrderAtomicSnapshotAndPermissions(t *testing.T) {
svc, db := newChannelModelTestService(t)
admin := &model.User{ID: "admin", Role: model.UserRoleAdmin}
for _, id := range []string{"a", "b", "c"} {
if err := db.Create(&model.ModelChannel{ID: id, Name: id, Scope: model.ChannelScopeSystem, Enabled: true}).Error; err != nil {
t.Fatal(err)
}
}
rows, err := svc.AdminChannelOrder(admin, "")
if err != nil {
t.Fatal(err)
}
original := []string{}
for _, row := range rows {
original = append(original, row.ID)
}
req := ChannelOrderRequest{IDs: []string{"c", "a", "b"}, ExpectedIDs: original}
if err := svc.SaveAdminChannelOrder(nil, "", req); err == nil {
t.Fatal("nonadmin accepted")
}
if err := svc.SaveAdminChannelOrder(admin, "", req); err != nil {
t.Fatal(err)
}
if err := svc.SaveAdminChannelOrder(admin, "", req); err == nil {
t.Fatal("stale snapshot accepted")
}
bad := ChannelOrderRequest{IDs: []string{"c", "c", "b"}, ExpectedIDs: []string{"c", "a", "b"}}
if err := svc.SaveAdminChannelOrder(admin, "", bad); err == nil {
t.Fatal("duplicate accepted")
}
after, _ := svc.AdminChannelOrder(admin, "")
if after[0].ID != "c" || after[1].ID != "a" {
t.Fatal("failed save changed order")
}
for _, id := range []string{"m1", "m2"} {
if err := db.Create(&model.ChannelModel{ID: id, ChannelID: "a", ModelKey: id, Enabled: true, PriceVersion: 7, CapabilityVersion: 4, UnitPriceMicrocredits: 123}).Error; err != nil {
t.Fatal(err)
}
}
models, _ := svc.AdminChannelOrder(admin, "a")
expected := []string{models[0].ID, models[1].ID}
if err := svc.SaveAdminChannelOrder(admin, "a", ChannelOrderRequest{IDs: []string{expected[1], expected[0]}, ExpectedIDs: expected}); err != nil {
t.Fatal(err)
}
var stored []model.ChannelModel
db.Find(&stored)
for _, item := range stored {
if item.PriceVersion != 7 || item.CapabilityVersion != 4 || item.UnitPriceMicrocredits != 123 || !item.Enabled {
t.Fatal("model configuration changed")
}
}
if err := svc.SaveAdminChannelOrder(admin, "b", ChannelOrderRequest{IDs: expected, ExpectedIDs: expected}); err == nil {
t.Fatal("cross-channel accepted")
}
}
@@ -0,0 +1,72 @@
package service
import (
"strings"
"time"
"infinite-canvas/backend/internal/model"
)
func (req ChannelRequest) presentationOnly() bool {
return (req.PublicAlias != nil || req.SortOrder != nil) && req.Name == "" && req.BaseURL == "" && req.AllowLocalChannel == nil && req.APIKey == "" && req.SecretKey == "" && req.ConcurrencyLimit == nil && req.UseGlobalConcurrency == nil && req.Models == nil && req.Headers == nil && req.Enabled == nil
}
func (s *Service) updateChannelPresentation(id string, req ChannelRequest) (*PublicModelChannel, error) {
if req.SortOrder != nil {
if err := validateChannelSortOrder(*req.SortOrder); err != nil {
return nil, err
}
}
if req.PublicAlias != nil {
alias := strings.TrimSpace(*req.PublicAlias)
if len([]rune(alias)) > 80 {
return nil, BadAuthRequest("前台别名不能超过 80 字")
}
req.PublicAlias = &alias
}
if err := s.repo.UpdateSystemChannelPresentation(id, req.PublicAlias, req.SortOrder, time.Now()); err != nil {
return nil, err
}
s.invalidateRouteCatalog()
channel, err := s.repo.AdminSystemChannel(id)
if err != nil {
return nil, err
}
items, err := s.repo.ChannelModels(id, true)
if err != nil {
return nil, err
}
public := publicChannel(*channel, true, items)
return &public, nil
}
type ChannelModelSortRequest struct {
SortOrder *int `json:"sortOrder"`
}
func validateChannelSortOrder(value int) error {
if value < 0 || value > 999999 {
return BadAuthRequest("排序值必须是 0-999999 的整数,数值越小越靠前")
}
return nil
}
func (s *Service) UpdateAdminChannelModelSort(actor *model.User, channelID, modelID string, req ChannelModelSortRequest) error {
if err := s.RequireAdmin(actor); err != nil {
return err
}
if req.SortOrder == nil {
return BadAuthRequest("请填写排序值")
}
if err := validateChannelSortOrder(*req.SortOrder); err != nil {
return err
}
if _, err := s.repo.AdminSystemChannel(channelID); err != nil {
return err
}
if err := s.repo.UpdateChannelModelSort(channelID, modelID, *req.SortOrder, time.Now()); err != nil {
return err
}
s.invalidateRouteCatalog()
return nil
}
@@ -0,0 +1,155 @@
package service
import (
"encoding/json"
"reflect"
"strings"
"testing"
"time"
"infinite-canvas/backend/internal/model"
)
func TestChannelPresentationAliasAndPublicOrder(t *testing.T) {
svc, db := newChannelModelTestService(t)
svc.dataDir = t.TempDir()
admin := &model.User{ID: "admin", Role: model.UserRoleAdmin}
for i, id := range []string{"first", "second"} {
channel := model.ModelChannel{ID: id, Name: "内部" + id, Scope: model.ChannelScopeSystem, Enabled: true, BaseURL: "https://dead.invalid/v1", ModelsJSON: `[]`, CreatedAt: time.Unix(int64(i+1), 0)}
if err := db.Create(&channel).Error; err != nil {
t.Fatal(err)
}
cm := model.ChannelModel{ID: id + "-model", ChannelID: id, ModelKey: id, Enabled: true, PriceConfigured: true, Capability: "image"}
if err := db.Create(&cm).Error; err != nil {
t.Fatal(err)
}
}
alias := " 创作精选 "
updated, err := svc.UpdateSystemChannel(admin, "second", ChannelRequest{PublicAlias: &alias})
if err != nil {
t.Fatal(err)
}
if updated.Name != "内部second" || updated.PublicAlias != "创作精选" {
t.Fatalf("admin alias: %#v", updated)
}
if _, err := svc.UpdateSystemChannel(admin, "first", ChannelRequest{SortOrder: intPtr(20)}); err != nil {
t.Fatal(err)
}
adminRows, total, err := svc.repo.AdminSystemChannels("", "all", 1, 0)
if err != nil || total != 2 || len(adminRows) != 1 || adminRows[0].ID != "second" {
t.Fatalf("pagination before sort: %v %v %v", adminRows, total, err)
}
search, _, err := svc.repo.AdminSystemChannels("精选", "all", 10, 0)
if err != nil || len(search) != 1 {
t.Fatalf("alias search: %v %v", search, err)
}
catalog, err := svc.publicSystemChannelCatalog(nil)
if err != nil {
t.Fatal(err)
}
if len(catalog) != 2 || catalog[0].ID != "second" || catalog[0].Name != "创作精选" || catalog[0].DisplayName != "创作精选" {
t.Fatalf("public catalog: %#v", catalog)
}
legacy, err := svc.PublicSystemChannels()
if err != nil {
t.Fatal(err)
}
if legacy[0].Name != "创作精选" {
t.Fatalf("public session: %#v", legacy)
}
encoded, _ := json.Marshal([]any{catalog[0], legacy[0]})
if strings.Contains(string(encoded), "内部second") {
t.Fatal("internal channel name leaked into public payload")
}
if _, err := svc.UpdateSystemChannel(admin, "second", ChannelRequest{SortOrder: intPtr(5)}); err != nil {
t.Fatal(err)
}
stored, _ := svc.repo.AdminSystemChannel("second")
if stored.PublicAlias != "创作精选" {
t.Fatal("partial sort patch cleared alias")
}
alias = " "
if _, err := svc.UpdateSystemChannel(admin, "second", ChannelRequest{PublicAlias: &alias, SortOrder: intPtr(0)}); err != nil {
t.Fatal(err)
}
catalog, err = svc.publicSystemChannelCatalog(nil)
if err != nil || catalog[0].Name != "内部second" {
t.Fatalf("empty alias fallback: %v %v", catalog, err)
}
for _, invalid := range []int{-1, 1000000} {
if _, err := svc.UpdateSystemChannel(admin, "second", ChannelRequest{SortOrder: &invalid}); err == nil {
t.Fatal("invalid sort accepted")
}
}
alias = strings.Repeat("字", 81)
if _, err := svc.UpdateSystemChannel(admin, "second", ChannelRequest{PublicAlias: &alias}); err == nil {
t.Fatal("long alias accepted")
}
}
func TestChannelModelSortPreservesConfigurationAndOwnership(t *testing.T) {
svc, db := newChannelModelTestService(t)
admin := &model.User{ID: "admin", Role: model.UserRoleAdmin}
for _, id := range []string{"channel", "other"} {
if err := db.Create(&model.ModelChannel{ID: id, Scope: model.ChannelScopeSystem, Enabled: true, Name: id, ModelsJSON: `[]`}).Error; err != nil {
t.Fatal(err)
}
}
for i, id := range []string{"z", "a", "b"} {
cm := model.ChannelModel{ID: id, ChannelID: "channel", ModelKey: id, ProviderModelKey: "provider-" + id, Enabled: true, Capability: "image", PriceConfigured: true, UnitPriceMicrocredits: 123, PriceVersion: 7, CapabilityVersion: 4, CapabilityConfigJSON: `{}`, CreatedAt: time.Unix(int64(i), 0)}
if err := db.Create(&cm).Error; err != nil {
t.Fatal(err)
}
}
var before model.ChannelModel
if err := db.First(&before, "id = ?", "z").Error; err != nil {
t.Fatal(err)
}
if err := svc.UpdateAdminChannelModelSort(admin, "channel", "z", ChannelModelSortRequest{SortOrder: intPtr(10)}); err != nil {
t.Fatal(err)
}
var after model.ChannelModel
if err := db.First(&after, "id = ?", "z").Error; err != nil {
t.Fatal(err)
}
after.SortOrder, after.UpdatedAt = before.SortOrder, before.UpdatedAt
if !reflect.DeepEqual(before, after) {
t.Fatal("sort changed model business configuration")
}
rows, err := svc.repo.ChannelModels("channel", true)
if err != nil || len(rows) != 3 || rows[0].ID != "a" || rows[1].ID != "b" || rows[2].ID != "z" {
t.Fatalf("sort and stable tie: %v %v", rows, err)
}
channel, _ := svc.repo.AdminSystemChannel("channel")
if channel.ModelsJSON != `["a","b","z"]` {
t.Fatalf("legacy models order: %s", channel.ModelsJSON)
}
catalog, err := svc.publicSystemChannelCatalog(nil)
if err != nil || len(catalog) != 1 || catalog[0].Models[2].ModelKey != "z" {
t.Fatalf("public model order: %v %v", catalog, err)
}
for _, tc := range []struct {
actor *model.User
channel, id string
value *int
}{
{nil, "channel", "z", intPtr(1)},
{&model.User{ID: "user"}, "channel", "z", intPtr(1)},
{admin, "other", "z", intPtr(1)},
{admin, "channel", "missing", intPtr(1)},
{admin, "channel", "z", nil},
{admin, "channel", "z", intPtr(-1)},
{admin, "channel", "z", intPtr(1000000)},
} {
if err := svc.UpdateAdminChannelModelSort(tc.actor, tc.channel, tc.id, ChannelModelSortRequest{SortOrder: tc.value}); err == nil {
t.Fatalf("invalid update accepted: %#v", tc)
}
}
if err := svc.UpdateAdminChannelModelSort(admin, "channel", "z", ChannelModelSortRequest{SortOrder: intPtr(0)}); err != nil {
t.Fatal(err)
}
rows, _ = svc.repo.ChannelModels("channel", true)
if rows[0].ID != "z" {
t.Fatal("resetting to zero did not restore creation order")
}
}
+23 -1
View File
@@ -67,6 +67,8 @@ type runtimeCoordinator struct {
}
var fixedWindowScript = redis.NewScript(`
local existing = tonumber(redis.call('GET', KEYS[1]) or '0')
if existing >= tonumber(ARGV[2]) then return existing + 1 end
local count = redis.call('INCR', KEYS[1])
if count == 1 then redis.call('PEXPIRE', KEYS[1], ARGV[1]) end
return count
@@ -108,7 +110,7 @@ func newRuntimeCoordinator(dialect string) (*runtimeCoordinator, error) {
func (c *runtimeCoordinator) allow(ctx context.Context, key string, limit int, window time.Duration) (bool, error) {
if c.redis != nil {
count, err := fixedWindowScript.Run(ctx, c.redis, []string{"canvas:rate:" + key}, window.Milliseconds()).Int64()
count, err := fixedWindowScript.Run(ctx, c.redis, []string{"canvas:rate:" + key}, window.Milliseconds(), limit).Int64()
return count <= int64(limit), err
}
c.localMu.Lock()
@@ -422,6 +424,26 @@ func (s *Service) AllowRequest(ctx context.Context, key string, limit int, windo
return s.coordinator.allow(ctx, key, limit, window)
}
func (s *Service) RequestRetryAfter(ctx context.Context, key string, window time.Duration) time.Duration {
c := s.coordinator
if c == nil {
return window
}
if c.redis != nil {
ttl, err := c.redis.PTTL(ctx, "canvas:rate:"+key).Result()
if err == nil && ttl > 0 {
return ttl
}
return window
}
c.localMu.Lock()
defer c.localMu.Unlock()
if entry, ok := c.localRate[key]; ok {
return max(time.Second, time.Until(entry.started.Add(window)))
}
return time.Second
}
func (s *Service) AcquireCustomRelaySlot(ctx context.Context, userID string, limit int, ttl time.Duration) (func(), bool, error) {
if s.coordinator == nil {
return nil, false, errors.New("运行时协调器未初始化")
+2 -1
View File
@@ -178,7 +178,8 @@ func (s *Service) SendRegistrationEmailCode(rawEmail string) error {
s.emailCodeMu.Lock()
defer s.emailCodeMu.Unlock()
if latest, err := s.repo.LatestEmailVerificationCode(email, registrationEmailPurpose); err == nil && time.Since(latest.CreatedAt) < time.Minute {
return BadAuthRequest("验证码发送过于频繁,请稍后再试")
seconds := max(1, int((time.Until(latest.CreatedAt.Add(time.Minute))+time.Second-1)/time.Second))
return &EmailCodeCooldownError{Seconds: seconds}
} else if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return err
}
@@ -0,0 +1,9 @@
package service
import "fmt"
type EmailCodeCooldownError struct{ Seconds int }
func (e *EmailCodeCooldownError) Error() string {
return fmt.Sprintf("验证码已发送,请查看邮箱;%d 秒后可以重新获取", e.Seconds)
}
+6 -2
View File
@@ -27,6 +27,7 @@ type PublicChannelCatalog struct {
ID string `json:"id"`
Name string `json:"name"`
DisplayName string `json:"displayName"`
SortOrder int `json:"sortOrder"`
Models []PublicChannelModel `json:"models"`
}
@@ -35,6 +36,7 @@ type PublicChannelModel struct {
ID string `json:"id"`
ModelKey string `json:"modelKey"`
DisplayName string `json:"displayName"`
SortOrder int `json:"sortOrder"`
Icon string `json:"icon"`
Capability string `json:"capability"`
Protocol model.ChannelInterfaceType `json:"protocol"`
@@ -127,8 +129,9 @@ func (s *Service) publicSystemChannelCatalog(intent *ModelRequestIntent) ([]Publ
if len(publicModels) > 0 {
result = append(result, PublicChannelCatalog{
ID: channel.ID,
Name: channel.Name,
DisplayName: channel.Name,
Name: channel.PublicName(),
DisplayName: channel.PublicName(),
SortOrder: channel.SortOrder,
Models: publicModels,
})
}
@@ -181,6 +184,7 @@ func (s *Service) sanitizeChannelModel(cm *model.ChannelModel) PublicChannelMode
ID: cm.ID,
ModelKey: cm.ModelKey,
DisplayName: cm.DisplayName,
SortOrder: cm.SortOrder,
Icon: cm.Icon,
Capability: cm.Capability,
Protocol: cm.Protocol,
@@ -0,0 +1,49 @@
package service
import (
"context"
"errors"
"infinite-canvas/backend/internal/model"
"testing"
"time"
)
func TestRegistrationCooldownAndFailedSMTPDoesNotBlockRetry(t *testing.T) {
svc, db := newPasswordResetTestService(t)
db.Create(&model.User{ID: "admin", Username: "admin", Role: model.UserRoleAdmin, Status: model.UserStatusActive})
db.Create(&model.SystemSetting{Key: registrationSettingKey, ValueJSON: `{"enabled":true}`})
svc.mailSender = func(emailSettingValue, string, string, string) error { return errors.New("synthetic SMTP failure") }
if err := svc.SendRegistrationEmailCode("new@example.com"); err == nil {
t.Fatal("SMTP error hidden")
}
sent := 0
svc.mailSender = func(emailSettingValue, string, string, string) error { sent++; return nil }
if err := svc.SendRegistrationEmailCode("new@example.com"); err != nil {
t.Fatal(err)
}
var cooldown *EmailCodeCooldownError
if err := svc.SendRegistrationEmailCode("new@example.com"); !errors.As(err, &cooldown) || cooldown.Seconds < 58 || cooldown.Seconds > 60 {
t.Fatalf("cooldown: %v", err)
}
if sent != 1 {
t.Fatal("duplicate mail sent")
}
}
func TestRequestRetryAfterMatchesWindow(t *testing.T) {
s := &Service{coordinator: &runtimeCoordinator{localRate: map[string]localRateEntry{}}}
ctx := context.Background()
if ok, err := s.AllowRequest(ctx, "email-code:test", 1, time.Hour); err != nil || !ok {
t.Fatal(err)
}
if ok, _ := s.AllowRequest(ctx, "email-code:test", 1, time.Hour); ok {
t.Fatal("limit bypassed")
}
wait := s.RequestRetryAfter(ctx, "email-code:test", time.Hour)
if wait < 59*time.Minute || wait > time.Hour {
t.Fatalf("wrong wait: %v", wait)
}
if s.coordinator.localRate["email-code:test"].count != 1 {
t.Fatal("rejection consumed quota")
}
}
@@ -351,6 +351,35 @@ func TestDetachedResourceCleanupRemovesOrphanAndKeepsAssetBackedResource(t *test
}
}
func TestDetachedResourceCleanupKeepsAppearanceAssets(t *testing.T) {
for _, setting := range []string{
`{"logoResourceId":"logo","darkLogoResourceId":"dark","authVideoResourceId":"video","authVideoPosterResourceId":"poster"}`,
`{invalid`,
} {
svc, db, _ := newResourceDeletionTestService(t)
if err := db.Create(&model.SystemSetting{Key: appearanceSettingKey, ValueJSON: setting}).Error; err != nil {
t.Fatal(err)
}
var resources []model.Resource
for _, id := range []string{"logo", "dark", "video", "poster"} {
resource := model.Resource{ID: id, UserID: "admin", Status: model.ResourceStatusReady, Provider: "local", ObjectKey: id, CreatedAt: time.Now().Add(-48 * time.Hour)}
if err := db.Create(&resource).Error; err != nil {
t.Fatal(err)
}
resources = append(resources, resource)
}
if err := svc.cleanupDetachedUserResources("admin", resources); err != nil {
t.Fatal(err)
}
var count, jobs int64
db.Model(&model.Resource{}).Count(&count)
db.Model(&model.ResourceDeletionJob{}).Count(&jobs)
if count != 4 || jobs != 0 {
t.Fatalf("appearance cleanup: resources=%d jobs=%d", count, jobs)
}
}
}
func TestResourceCleanupCandidatesUseStatusSpecificRetention(t *testing.T) {
_, db, _ := newResourceDeletionTestService(t)
now := time.Now()
@@ -76,6 +76,10 @@ func (s *Service) cleanupDetachedUserResources(userID string, candidates []model
return err
}
referenced := map[string]struct{}{}
// Site assets are global references and are not part of a user's canvas snapshot.
for resourceID := range s.appearanceResourceReferences(resourceIDs) {
referenced[resourceID] = struct{}{}
}
for _, reference := range snapshot.Direct {
if _, exists := candidateSet[reference.ResourceID]; exists {
referenced[reference.ResourceID] = struct{}{}
+2 -2
View File
@@ -134,8 +134,8 @@ func defaultRuntimePolicy() RuntimePolicySetting {
SessionFilePerMinute: 30,
AssetWritePerMinute: 120,
CanvasWritePerMinute: 120,
RegisterPerHour: 5,
EmailCodePerHour: 10,
RegisterPerHour: 30,
EmailCodePerHour: 60,
LoginIPPerTenMinutes: 50,
LoginAccountPerTenMinutes: 10,
SystemRelayPerMinute: 120,