feat: 迁移自定义功能至 1.5.9.9 版本

包含音乐源限制、CI 防 OOM 优化、数据库连接池优化、管理端权限及 UI 细节定制等功能

server/api/admin/users/batch-status.put.ts

@@ -4,8 +4,6 @@ import { users, userStatusLogs } from '~/drizzle/schema'
 import { and, eq, inArray } from 'drizzle-orm'
 import { getBeijingTime } from '~/utils/timeUtils'
 import { getStatusText } from '~~/server/utils/user'
-import { createApiError } from '~~/server/utils/apiError'
-import { SERVER_ERROR_CODES } from '~~/server/config/constants'
 
 export default defineEventHandler(async (event) => {
   try {
@@ -14,76 +12,51 @@ export default defineEventHandler(async (event) => {
     if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
       throw createError({
         statusCode: 403,
-        message: '没有权限访问'
+        statusMessage: '没有权限访问'
       })
     }
 
     const body = await readBody(event)
-    const { userIds, status, reason, sourceStatus } = body
-    const sourceStatusFilter = typeof sourceStatus === 'string' ? sourceStatus.trim() : ''
+    const { userIds, status, reason } = body
 
     // 验证必填字段
     if (!Array.isArray(userIds) || userIds.length === 0) {
       throw createError({
         statusCode: 400,
-        message: '用户ID列表不能为空'
+        statusMessage: '用户ID列表不能为空'
       })
     }
 
     if (!status || !['active', 'withdrawn', 'graduate'].includes(status)) {
       throw createError({
         statusCode: 400,
-        message: '状态必须为 active, withdrawn 或 graduate'
+        statusMessage: '状态必须为 active, withdrawn 或 graduate'
       })
     }
 
-    // 源状态白名单含 pending（支持按待审核筛选批量处理；同时使下方 pending→active 拦截可达）
-    if (sourceStatusFilter && !['active', 'pending', 'withdrawn', 'graduate'].includes(sourceStatusFilter)) {
-      throw createError({
-        statusCode: 400,
-        message: '前置状态必须为 active, pending, withdrawn 或 graduate'
-      })
-    }
-
-    if (sourceStatusFilter === status) {
-      throw createError({
-        statusCode: 400,
-        message: '前置状态不能与目标状态相同'
-      })
-    }
-
-    // 待审核用户不得通过批量状态接口直接置为 active（须走注册审核流程）
-    if (sourceStatusFilter === 'pending' && status === 'active') {
-      throw createApiError(400, SERVER_ERROR_CODES.USER_NOT_PENDING, '待审核用户需通过注册审核流程处理')
-    }
-
     if (!reason || reason.trim().length === 0) {
       throw createError({
         statusCode: 400,
-        message: '变更原因为必填项'
+        statusMessage: '变更原因为必填项'
       })
     }
 
     // 验证用户ID格式
-    const validUserIds = [
-      ...new Set(
-        userIds
-          .filter((id) => {
-            const numId = parseInt(id)
-            return !isNaN(numId) && numId > 0
-          })
-          .map((id) => parseInt(id))
-      )
-    ]
+    const validUserIds = userIds
+      .filter((id) => {
+        const numId = parseInt(id)
+        return !isNaN(numId) && numId > 0
+      })
+      .map((id) => parseInt(id))
 
     if (validUserIds.length === 0) {
       throw createError({
         statusCode: 400,
-        message: '没有有效的用户ID'
+        statusMessage: '没有有效的用户ID'
       })
     }
 
-    // 检查用户是否存在
+    // 检查用户是否存在且为学生角色
     const existingUsers = await db
       .select({
         id: users.id,
@@ -93,69 +66,23 @@ export default defineEventHandler(async (event) => {
         role: users.role
       })
       .from(users)
-      .where(inArray(users.id, validUserIds))
+      .where(and(inArray(users.id, validUserIds), eq(users.role, 'USER')))
 
-    const existingUserIds = existingUsers.map((u) => u.id)
-    const nonExistentUserIds = validUserIds.filter((id) => !existingUserIds.includes(id))
-
-    // 筛选出状态需要变更的用户，并加入越权保护，同时记录失败原因
-    const usersToUpdate = []
-    const errors: Array<{ userId: number | string; error: string }> = []
-
-    if (nonExistentUserIds.length > 0) {
-      nonExistentUserIds.forEach((id) => {
-        errors.push({ userId: id, error: '用户不存在' })
+    if (existingUsers.length === 0) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: '没有找到可更新的学生用户'
       })
     }
 
-    for (const u of existingUsers) {
-      if (u.id === 1) {
-        errors.push({ userId: u.id, error: '无法修改系统初始超级管理员' })
-        continue
-      }
-      if (u.id === user.id) {
-        errors.push({ userId: u.id, error: '禁止在用户管理中批量更新自己的账户' })
-        continue
-      }
-      if (u.role === 'SUPER_ADMIN' && user.role !== 'SUPER_ADMIN') {
-        errors.push({ userId: u.id, error: '权限不足：普通管理员无法修改超级管理员信息' })
-        continue
-      }
-      if (u.role !== 'USER' && user.role !== 'SUPER_ADMIN') {
-        errors.push({ userId: u.id, error: '权限不足：普通管理员无法批量修改其他管理员状态' })
-        continue
-      }
-      if (sourceStatusFilter && u.status !== sourceStatusFilter) {
-        errors.push({
-          userId: u.id,
-          error: `前置状态不匹配：当前为${getStatusText(u.status)}，仅更新${getStatusText(sourceStatusFilter)}`
-        })
-        continue
-      }
-      // 待审核用户不得通过批量状态接口直接置为 active（须走注册审核流程；即使未传 sourceStatus 也按实际状态拦截）
-      if (status === 'active' && u.status === 'pending') {
-        errors.push({ userId: u.id, error: '待审核用户需通过注册审核流程处理' })
-        continue
-      }
-      if (u.status === status) {
-        errors.push({ userId: u.id, error: '用户状态无需变更' })
-        continue
-      }
-      usersToUpdate.push(u)
-    }
+    // 筛选出状态需要变更的用户
+    const usersToUpdate = existingUsers.filter((u) => u.status !== status)
 
     if (usersToUpdate.length === 0) {
-      return {
-        success: false,
-        message: '没有可更新的合法用户',
-        errors,
-        data: {
-          totalRequested: validUserIds.length,
-          totalUpdated: 0,
-          updatedUsers: [],
-          sourceStatus: sourceStatusFilter || null
-        }
-      }
+      throw createError({
+        statusCode: 400,
+        statusMessage: '所选用户的状态均无需变更'
+      })
     }
 
     const currentTime = getBeijingTime()
@@ -194,15 +121,24 @@ export default defineEventHandler(async (event) => {
       }
     })
 
+    // 清除相关缓存
+    try {
+      const { cache } = await import('~~/server/utils/cache-helpers')
+      for (const userId of usersToUpdate.map((u) => u.id)) {
+        await cache.delete(`auth:user:${userId}`)
+      }
+      console.log('[Cache] 批量用户认证缓存已清除（状态更新）')
+    } catch (cacheError) {
+      console.warn('[Cache] 清除缓存失败:', cacheError)
+    }
+
     return {
       success: true,
       message: `成功更新 ${results.length} 个用户的状态为${getStatusText(status)}`,
-      errors,
       data: {
         totalRequested: validUserIds.length,
         totalUpdated: results.length,
         updatedUsers: results,
-        sourceStatus: sourceStatusFilter || null,
         changedAt: currentTime,
         changedBy: user.name
       }
@@ -216,7 +152,7 @@ export default defineEventHandler(async (event) => {
 
     throw createError({
       statusCode: 500,
-      message: '批量更新用户状态失败: ' + error.message
+      statusMessage: '批量更新用户状态失败: ' + error.message
     })
   }
 })