feat(accounts): 支持用户账号批量编辑

新增用户账号批量更新接口与路由，校验账号归属、状态、分组绑定及用户可更新字段。前端用户账号页加入批量选择和批量编辑入口，复用批量编辑弹窗并按用户作用域屏蔽代理、费率、Base URL 等管理员字段。同时补充用户批量更新 API、disabled 状态文案与相关测试，并修正用户仪表盘本地日期格式化。

Author: Open-Pixel-AI

backend/internal/handler/user_account_handler.go

@@ -95,6 +95,20 @@ type updateUserAccountRequest struct {
 	AutoPauseOnExpired *bool           `json:"auto_pause_on_expired"`
 }
 
+type bulkUpdateUserAccountsRequest struct {
+	AccountIDs     []int64        `json:"account_ids"`
+	ProxyID        *int64         `json:"proxy_id"`
+	Concurrency    *int           `json:"concurrency"`
+	LoadFactor     *int           `json:"load_factor"`
+	Priority       *int           `json:"priority"`
+	RateMultiplier *float64       `json:"rate_multiplier"`
+	Status         string         `json:"status" binding:"omitempty,oneof=active disabled inactive"`
+	Schedulable    *bool          `json:"schedulable"`
+	GroupIDs       *[]int64       `json:"group_ids"`
+	Credentials    map[string]any `json:"credentials"`
+	Extra          map[string]any `json:"extra"`
+}
+
 type userOAuthProxyRequest struct {
 	ProxyID *int64 `json:"proxy_id"`
 }
@@ -717,6 +731,79 @@ func (h *UserAccountHandler) Update(c *gin.Context) {
 	response.Success(c, dto.AccountFromService(account))
 }
 
+func (h *UserAccountHandler) BulkUpdate(c *gin.Context) {
+	subject, ok := middleware2.GetAuthSubjectFromContext(c)
+	if !ok {
+		response.Unauthorized(c, "User not authenticated")
+		return
+	}
+
+	var req bulkUpdateUserAccountsRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.BadRequest(c, "Invalid request: "+err.Error())
+		return
+	}
+	accountIDs := normalizeUserAccountIDList(req.AccountIDs)
+	if len(accountIDs) == 0 {
+		response.BadRequest(c, "account_ids is required")
+		return
+	}
+	if !rejectUserProxyID(c, req.ProxyID) {
+		return
+	}
+	if req.RateMultiplier != nil {
+		response.BadRequest(c, "rate_multiplier is not allowed for user accounts")
+		return
+	}
+
+	status := strings.ToLower(strings.TrimSpace(req.Status))
+	if status == "inactive" {
+		status = service.StatusDisabled
+	}
+	if req.Concurrency != nil && *req.Concurrency <= 0 {
+		response.BadRequest(c, "concurrency must be > 0")
+		return
+	}
+	if req.Priority != nil && *req.Priority <= 0 {
+		response.BadRequest(c, "priority must be > 0")
+		return
+	}
+	if req.LoadFactor != nil && *req.LoadFactor > 10000 {
+		response.BadRequest(c, "load_factor must be <= 10000")
+		return
+	}
+
+	hasUpdates := req.Concurrency != nil ||
+		req.LoadFactor != nil ||
+		req.Priority != nil ||
+		status != "" ||
+		req.Schedulable != nil ||
+		req.GroupIDs != nil ||
+		len(req.Credentials) > 0 ||
+		len(req.Extra) > 0
+	if !hasUpdates {
+		response.BadRequest(c, "No updates provided")
+		return
+	}
+
+	result, err := h.accountService.BulkUpdateOwned(c.Request.Context(), subject.UserID, &service.BulkUpdateOwnedAccountsInput{
+		AccountIDs:  accountIDs,
+		Concurrency: req.Concurrency,
+		LoadFactor:  req.LoadFactor,
+		Priority:    req.Priority,
+		Status:      status,
+		Schedulable: req.Schedulable,
+		GroupIDs:    req.GroupIDs,
+		Credentials: req.Credentials,
+		Extra:       req.Extra,
+	})
+	if err != nil {
+		response.ErrorFrom(c, err)
+		return
+	}
+	response.Success(c, result)
+}
+
 func (h *UserAccountHandler) Delete(c *gin.Context) {
 	subject, ok := middleware2.GetAuthSubjectFromContext(c)
 	if !ok {

backend/internal/server/routes/user.go

@@ -73,6 +73,7 @@ func RegisterUserRoutes(
 			accounts.POST("", h.UserAccount.Create)
 			accounts.POST("/import", h.UserAccount.Import)
 			accounts.POST("/import-credentials", h.UserAccount.ImportCredentials)
+			accounts.POST("/bulk-update", h.UserAccount.BulkUpdate)
 			accounts.PUT("/:id", h.UserAccount.Update)
 			accounts.DELETE("/:id", h.UserAccount.Delete)
 		}

backend/internal/service/account_service.go

@@ -177,6 +177,18 @@ type AccountListFilters struct {
 	PrivacyMode string
 }
 
+type BulkUpdateOwnedAccountsInput struct {
+	AccountIDs  []int64
+	Concurrency *int
+	Priority    *int
+	LoadFactor  *int
+	Status      string
+	Schedulable *bool
+	GroupIDs    *[]int64
+	Credentials map[string]any
+	Extra       map[string]any
+}
+
 // NewAccountService 创建账号服务实例
 func NewAccountService(
 	accountRepo AccountRepository,
@@ -640,6 +652,157 @@ func (s *AccountService) DeleteOwned(ctx context.Context, ownerUserID, accountID
 // Delete 删除账号
 // 优化：使用 ExistsByID 替代 GetByID 进行存在性检查，
 // 避免加载完整账号对象及其关联数据，提升删除操作的性能
+func normalizeOwnedBulkAccountIDs(ids []int64) []int64 {
+	if len(ids) == 0 {
+		return nil
+	}
+	out := make([]int64, 0, len(ids))
+	seen := make(map[int64]struct{}, len(ids))
+	for _, id := range ids {
+		if id <= 0 {
+			continue
+		}
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		out = append(out, id)
+	}
+	return out
+}
+
+func normalizeOwnedBulkStatus(status string) (string, error) {
+	normalized := strings.ToLower(strings.TrimSpace(status))
+	if normalized == "" {
+		return "", nil
+	}
+	if normalized == "inactive" {
+		normalized = StatusDisabled
+	}
+	switch normalized {
+	case StatusActive, StatusDisabled:
+		return normalized, nil
+	default:
+		return "", fmt.Errorf("invalid account status: %s", status)
+	}
+}
+
+func mergeAccountMap(current map[string]any, updates map[string]any) map[string]any {
+	if len(current) == 0 && len(updates) == 0 {
+		return nil
+	}
+	next := make(map[string]any, len(current)+len(updates))
+	for key, value := range current {
+		next[key] = value
+	}
+	for key, value := range updates {
+		next[key] = value
+	}
+	return next
+}
+
+func (s *AccountService) BulkUpdateOwned(ctx context.Context, ownerUserID int64, input *BulkUpdateOwnedAccountsInput) (*BulkUpdateAccountsResult, error) {
+	if ownerUserID <= 0 {
+		return nil, ErrUserNotFound
+	}
+	if input == nil {
+		return nil, ErrAccountNilInput
+	}
+
+	accountIDs := normalizeOwnedBulkAccountIDs(input.AccountIDs)
+	result := &BulkUpdateAccountsResult{
+		SuccessIDs: make([]int64, 0, len(accountIDs)),
+		FailedIDs:  make([]int64, 0, len(accountIDs)),
+		Results:    make([]BulkUpdateAccountResult, 0, len(accountIDs)),
+	}
+	if len(accountIDs) == 0 {
+		return result, nil
+	}
+
+	if input.Concurrency != nil && *input.Concurrency <= 0 {
+		return nil, fmt.Errorf("concurrency must be > 0")
+	}
+	if input.Priority != nil && *input.Priority <= 0 {
+		return nil, fmt.Errorf("priority must be > 0")
+	}
+	if input.LoadFactor != nil && *input.LoadFactor > 10000 {
+		return nil, fmt.Errorf("load_factor must be <= 10000")
+	}
+	status, err := normalizeOwnedBulkStatus(input.Status)
+	if err != nil {
+		return nil, err
+	}
+
+	accounts, err := s.accountRepo.GetByIDs(ctx, accountIDs)
+	if err != nil {
+		return nil, fmt.Errorf("get accounts: %w", err)
+	}
+	accountsByID := make(map[int64]*Account, len(accounts))
+	for _, account := range accounts {
+		if account != nil {
+			accountsByID[account.ID] = account
+		}
+	}
+
+	validatedGroupIDsByAccount := make(map[int64][]int64, len(accountIDs))
+	for _, accountID := range accountIDs {
+		account := accountsByID[accountID]
+		if account == nil || account.OwnerUserID == nil || *account.OwnerUserID != ownerUserID {
+			return nil, ErrAccountNotFound
+		}
+
+		nextCredentials := mergeAccountMap(account.Credentials, input.Credentials)
+		nextExtra := mergeAccountMap(account.Extra, input.Extra)
+		if err := validateOwnedAccountSource(account.Type, nextCredentials, nextExtra); err != nil {
+			return nil, err
+		}
+
+		if input.GroupIDs != nil {
+			groupIDs, err := s.validateOwnedAccountGroupBinding(ctx, ownerUserID, account.Platform, account.Type, *input.GroupIDs)
+			if err != nil {
+				return nil, err
+			}
+			validatedGroupIDsByAccount[accountID] = groupIDs
+		}
+	}
+
+	repoUpdates := AccountBulkUpdate{
+		Concurrency: input.Concurrency,
+		Priority:    input.Priority,
+		LoadFactor:  input.LoadFactor,
+		Schedulable: input.Schedulable,
+		Credentials: input.Credentials,
+		Extra:       input.Extra,
+	}
+	if status != "" {
+		repoUpdates.Status = &status
+	}
+
+	if _, err := s.accountRepo.BulkUpdate(ctx, accountIDs, repoUpdates); err != nil {
+		return nil, fmt.Errorf("bulk update accounts: %w", err)
+	}
+
+	for _, accountID := range accountIDs {
+		entry := BulkUpdateAccountResult{AccountID: accountID}
+		if input.GroupIDs != nil {
+			if err := s.accountRepo.BindGroups(ctx, accountID, validatedGroupIDsByAccount[accountID]); err != nil {
+				entry.Success = false
+				entry.Error = err.Error()
+				result.Failed++
+				result.FailedIDs = append(result.FailedIDs, accountID)
+				result.Results = append(result.Results, entry)
+				continue
+			}
+		}
+		entry.Success = true
+		result.Success++
+		result.SuccessIDs = append(result.SuccessIDs, accountID)
+		result.Results = append(result.Results, entry)
+	}
+
+	return result, nil
+}
+
 func (s *AccountService) Delete(ctx context.Context, id int64) error {
 	// 使用轻量级的存在性检查，而非加载完整账号对象
 	exists, err := s.accountRepo.ExistsByID(ctx, id)

frontend/src/api/accounts.ts

@@ -99,6 +99,29 @@ export async function toggleStatus(id: number, status: 'active' | 'disabled'): P
   return update(id, { status })
 }
 
+export async function bulkUpdate(
+  accountIds: number[],
+  updates: Partial<UpdateAccountRequest>
+): Promise<{
+  success: number
+  failed: number
+  success_ids?: number[]
+  failed_ids?: number[]
+  results: Array<{ account_id: number; success: boolean; error?: string }>
+}> {
+  const { data } = await apiClient.post<{
+    success: number
+    failed: number
+    success_ids?: number[]
+    failed_ids?: number[]
+    results: Array<{ account_id: number; success: boolean; error?: string }>
+  }>('/accounts/bulk-update', {
+    account_ids: accountIds,
+    ...updates
+  })
+  return data
+}
+
 export async function getUsage(id: number, source?: 'passive' | 'active'): Promise<AccountUsageInfo> {
   const { data } = await apiClient.get<AccountUsageInfo>(`/accounts/${id}/usage`, {
     params: source ? { source } : undefined
@@ -326,6 +349,7 @@ export const accountsAPI = {
   update,
   delete: deleteAccount,
   toggleStatus,
+  bulkUpdate,
   getUsage,
   getTodayStats,
   getBatchTodayStats,