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

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

server/api/admin/stats/active-users.get.ts

@@ -1,11 +1,12 @@
 import { createError, defineEventHandler, getQuery } from 'h3'
 import { db } from '~/drizzle/db'
-import { songs, users, votes } from '~/drizzle/schema'
+import { songs, users, votes, userIdentities } from '~/drizzle/schema'
+import { CacheService } from '~~/server/services/cacheService'
+import { getUserAvatarUrl } from '~~/server/utils/user-avatar'
 
 export default defineEventHandler(async (event) => {
-  // 检查认证和权限
   const user = event.context.user
-  if (!user || !['SONG_ADMIN', 'ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
+  if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
     throw createError({
       statusCode: 403,
       message: '需要管理员权限'
@@ -17,18 +18,31 @@ export default defineEventHandler(async (event) => {
   const limit = parseInt(query.limit as string) || 20
 
   try {
-    // 构建查询条件 - 如果没有指定学期或学期为'all'，查询所有用户
+    const cacheService = CacheService.getInstance()
+    const cachedStats = await cacheService.getActiveUsersStats(semester, limit)
+    if (cachedStats) {
+      console.log('[Cache] 活跃用户统计数据缓存命中')
+      return cachedStats
+    }
+
     let songWhere = {}
     if (semester && semester !== 'all') {
       songWhere = { semester: semester }
     }
 
-    // 获取活跃用户数据 - 有投稿歌曲的用户
     const allUsers = await db.select().from(users)
     const allSongs = await db.select().from(songs)
     const allVotes = await db.select().from(votes)
+    const allIdentities = await db.select().from(userIdentities)
+
+    const identitiesMap = new Map<number, typeof allIdentities>()
+    allIdentities.forEach((identity) => {
+      if (!identitiesMap.has(identity.userId)) {
+        identitiesMap.set(identity.userId, [])
+      }
+      identitiesMap.get(identity.userId)!.push(identity)
+    })
 
-    // 过滤有投稿歌曲的用户
     const activeUsers = allUsers
       .filter((user) => {
         const userSongs = allSongs.filter((song) => {
@@ -56,37 +70,48 @@ export default defineEventHandler(async (event) => {
         }
       })
 
-    // 如果没有活跃用户，返回空数组
     if (activeUsers.length === 0) {
       const emptyResult = []
+      await cacheService.setActiveUsersStats(semester, limit, emptyResult)
+      console.log('[Cache] 活跃用户统计数据已缓存（空结果）')
       return emptyResult
     }
 
-    // 计算每个用户的活跃度数据
     const userStats = activeUsers.map((user) => {
       const contributions = user.songs.length
       const likes = user.songs.reduce((total, song) => total + song.votes.length, 0)
-
-      // 活跃度计算：投稿数 * 2 + 点赞数 * 0.5
       const activityScore = Math.round(contributions * 2 + likes * 0.5)
+      const userIdentitiesData = identitiesMap.get(user.id) || []
+      const avatarUrl = getUserAvatarUrl(
+        {
+          id: user.id,
+          name: user.name,
+          username: user.username,
+          email: user.email,
+          avatarProvider: user.avatarProvider,
+          avatarProviderUserId: user.avatarProviderUserId
+        },
+        userIdentitiesData
+      )
 
-      const userStat = {
+      return {
         id: user.id,
-        name: user.name || user.username, // 优先显示真实姓名，如果没有则显示登录名
+        name: user.name || user.username,
         contributions,
         likes,
-        activityScore
+        activityScore,
+        avatarUrl
       }
-
-      return userStat
     })
 
-    // 按活跃度分数降序排列并限制数量
     const sortedUsers = userStats.sort((a, b) => b.activityScore - a.activityScore).slice(0, limit)
 
+    await cacheService.setActiveUsersStats(semester, limit, sortedUsers)
+    console.log('[Cache] 活跃用户统计数据已缓存')
+
     return sortedUsers
   } catch (error) {
-    // 返回空数组而不是抛出错误，避免前端显示错误
+    console.error('[Stats] 获取活跃用户失败:', error)
     return []
   }
 })

server/api/admin/stats/realtime.get.ts

@@ -1,14 +1,26 @@
 import { createError, defineEventHandler } from 'h3'
 import { db } from '~/drizzle/db'
-import { songs, users, userIdentities, votes } from '~/drizzle/schema'
+import { CacheService } from '~~/server/services/cacheService'
+import { songs, users, votes, userIdentities } from '~/drizzle/schema'
 import { count, eq, gte, inArray } from 'drizzle-orm'
 import { getBeijingHour, getBeijingStartOfDay } from '~/utils/timeUtils'
-import { resolveAvatarSource } from '~~/server/utils/user-avatar'
+import { getUserAvatarUrl } from '~~/server/utils/user-avatar'
+
+function formatRelativeTime(date: Date | null | undefined): string {
+  if (!date) return '未知'
+  const now = new Date()
+  const diff = now.getTime() - new Date(date).getTime()
+  const minutes = Math.floor(diff / 60000)
+  if (minutes < 1) return '刚刚'
+  if (minutes < 60) return `${minutes}分钟前`
+  const hours = Math.floor(minutes / 60)
+  if (hours < 24) return `${hours}小时前`
+  return `${Math.floor(hours / 24)}天前`
+}
 
 export default defineEventHandler(async (event) => {
-  // 检查认证和权限
   const user = event.context.user
-  if (!user || !['SONG_ADMIN', 'ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
+  if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
     throw createError({
       statusCode: 403,
       message: '需要管理员权限'
@@ -16,140 +28,172 @@ export default defineEventHandler(async (event) => {
   }
 
   try {
-    // 获取当前时间相关的日期
+    const cacheService = CacheService.getInstance()
+    const cachedStats = await cacheService.getRealtimeStats()
+    if (cachedStats) {
+      console.log('[Cache] 实时统计数据缓存命中')
+      return cachedStats
+    }
     const now = new Date()
-    const today = getBeijingStartOfDay() // 使用北京时间的一天开始
+    const today = getBeijingStartOfDay()
     const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1000)
     const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000)
 
-    // 并行获取实时统计数据
     const [activeUsersData, todayRequests, popularGenres, peakHours] = await Promise.all([
-      // 活跃用户数和用户列表 (最近1小时点歌、登录或点赞的用户)
       (async () => {
         try {
-          // 获取最近1小时内点歌的用户
           const recentSongUsers = await db
             .select({
               requesterId: songs.requesterId,
               requesterName: users.name,
               requesterUsername: users.username,
-              requesterId2: users.id
+              requesterId2: users.id,
+              requesterLastActive: songs.createdAt,
+              requesterAvatarProvider: users.avatarProvider,
+              requesterAvatarProviderUserId: users.avatarProviderUserId,
+              requesterEmail: users.email
             })
             .from(songs)
             .innerJoin(users, eq(songs.requesterId, users.id))
             .where(gte(songs.createdAt, oneHourAgo))
-            .groupBy(songs.requesterId, users.id, users.name, users.username)
+            .groupBy(songs.requesterId, users.id, users.name, users.username, users.lastLogin, users.avatarProvider, users.avatarProviderUserId, users.email, songs.createdAt)
 
-          // 获取最近1小时内登录的用户
           const recentLoginUsers = await db
             .select({
               id: users.id,
               username: users.username,
-              name: users.name
+              name: users.name,
+              lastLogin: users.lastLogin,
+              avatarProvider: users.avatarProvider,
+              avatarProviderUserId: users.avatarProviderUserId,
+              email: users.email
             })
             .from(users)
             .where(gte(users.lastLogin, oneHourAgo))
 
-          // 获取最近1小时内点赞过歌曲的用户
           const recentVoteUsers = await db
             .select({
               userId: votes.userId,
               userName: users.name,
               userUsername: users.username,
-              userId2: users.id
+              userId2: users.id,
+              voteCreatedAt: votes.createdAt,
+              userAvatarProvider: users.avatarProvider,
+              userAvatarProviderUserId: users.avatarProviderUserId,
+              userEmail: users.email
             })
             .from(votes)
             .innerJoin(users, eq(votes.userId, users.id))
             .where(gte(votes.createdAt, oneHourAgo))
-            .groupBy(votes.userId, users.id, users.name, users.username)
+            .groupBy(votes.userId, users.id, users.name, users.username, users.avatarProvider, users.avatarProviderUserId, users.email, votes.createdAt)
 
-          // 合并并去重用户列表
-          const userMap = new Map()
+          const userMap = new Map<number, any>()
 
-          // 添加点歌用户
           recentSongUsers.forEach((song) => {
-            userMap.set(song.requesterId2, {
-              id: song.requesterId2,
+            const id = song.requesterId2
+            const existing = userMap.get(id)
+            const lastActive = existing?.lastActive
+              ? new Date(existing.lastActive) > new Date(song.requesterLastActive)
+                ? existing.lastActive
+                : song.requesterLastActive
+              : song.requesterLastActive
+            userMap.set(id, {
+              id,
               username: song.requesterUsername,
               name: song.requesterName,
-              avatar: null
+              email: song.requesterEmail,
+              avatarProvider: song.requesterAvatarProvider,
+              avatarProviderUserId: song.requesterAvatarProviderUserId,
+              lastActive
             })
           })
 
-          // 添加登录用户
-          recentLoginUsers.forEach((user) => {
-            userMap.set(user.id, {
-              id: user.id,
-              username: user.username,
-              name: user.name,
-              avatar: null
+          recentLoginUsers.forEach((u) => {
+            const existing = userMap.get(u.id)
+            const lastActive = existing?.lastActive
+              ? new Date(existing.lastActive) > new Date(u.lastLogin)
+                ? existing.lastActive
+                : u.lastLogin
+              : u.lastLogin
+            userMap.set(u.id, {
+              id: u.id,
+              username: u.username,
+              name: u.name,
+              email: u.email,
+              avatarProvider: u.avatarProvider,
+              avatarProviderUserId: u.avatarProviderUserId,
+              lastActive
             })
           })
 
-          // 添加点赞用户
           recentVoteUsers.forEach((vote) => {
-            userMap.set(vote.userId2, {
-              id: vote.userId2,
+            const id = vote.userId2
+            const existing = userMap.get(id)
+            const lastActive = existing?.lastActive
+              ? new Date(existing.lastActive) > new Date(vote.voteCreatedAt)
+                ? existing.lastActive
+                : vote.voteCreatedAt
+              : vote.voteCreatedAt
+            userMap.set(id, {
+              id,
               username: vote.userUsername,
               name: vote.userName,
-              avatar: null
+              email: vote.userEmail,
+              avatarProvider: vote.userAvatarProvider,
+              avatarProviderUserId: vote.userAvatarProviderUserId,
+              lastActive
             })
           })
 
-          // 解析头像（与用户管理面板同源：优先用户选中的身份，否则按创建顺序取第一个可用头像）
-          const activeUserIds = Array.from(userMap.keys())
-          if (activeUserIds.length > 0) {
-            const [userPrefs, identities] = await Promise.all([
-              db
-                .select({
-                  id: users.id,
-                  avatarProvider: users.avatarProvider,
-                  avatarProviderUserId: users.avatarProviderUserId
-                })
-                .from(users)
-                .where(inArray(users.id, activeUserIds)),
-              db
-                .select({
-                  userId: userIdentities.userId,
-                  provider: userIdentities.provider,
-                  providerUsername: userIdentities.providerUsername,
-                  providerUserId: userIdentities.providerUserId,
-                  avatar: userIdentities.avatar,
-                  createdAt: userIdentities.createdAt
-                })
+          const userIds = Array.from(userMap.keys())
+          let identitiesData: any[] = []
+          if (userIds.length > 0) {
+            try {
+              identitiesData = await db
+                .select()
                 .from(userIdentities)
-                .where(inArray(userIdentities.userId, activeUserIds))
-            ])
-
-            const prefsMap = new Map(userPrefs.map((pref) => [pref.id, pref]))
-            const identitiesMap = new Map()
-            identities.forEach((identity) => {
-              if (!identitiesMap.has(identity.userId)) {
-                identitiesMap.set(identity.userId, [])
-              }
-              identitiesMap.get(identity.userId).push(identity)
-            })
-
-            userMap.forEach((info, id) => {
-              const pref = prefsMap.get(id)
-              const avatarSource = resolveAvatarSource(
-                {
-                  avatarProvider: pref?.avatarProvider,
-                  avatarProviderUserId: pref?.avatarProviderUserId
-                },
-                identitiesMap.get(id) || []
-              )
-              info.avatar = avatarSource?.url ?? null
-            })
+                .where(inArray(userIdentities.userId, userIds))
+            } catch (e) {
+              identitiesData = []
+            }
           }
 
-          const activeUsersList = Array.from(userMap.values())
+          const identitiesMap = new Map<number, any[]>()
+          identitiesData.forEach((identity) => {
+            if (!identitiesMap.has(identity.userId)) {
+              identitiesMap.set(identity.userId, [])
+            }
+            identitiesMap.get(identity.userId)!.push(identity)
+          })
+
+          const activeUsersList = Array.from(userMap.values()).map((u) => {
+            const userIdentitiesData = identitiesMap.get(u.id) || []
+            const avatarUrl = getUserAvatarUrl(
+              {
+                id: u.id,
+                name: u.name,
+                username: u.username,
+                email: u.email,
+                avatarProvider: u.avatarProvider,
+                avatarProviderUserId: u.avatarProviderUserId
+              },
+              userIdentitiesData
+            )
+            return {
+              id: u.id,
+              username: u.username,
+              name: u.name,
+              avatarUrl,
+              lastActive: formatRelativeTime(u.lastActive)
+            }
+          })
 
           return {
             count: activeUsersList.length,
             users: activeUsersList
           }
         } catch (error) {
+          console.error('[Realtime] 获取活跃用户失败:', error)
           return {
             count: 0,
             users: []
@@ -157,7 +201,6 @@ export default defineEventHandler(async (event) => {
         }
       })(),
 
-      // 今日点歌数
       (async () => {
         try {
           const todayCountResult = await db
@@ -170,12 +213,10 @@ export default defineEventHandler(async (event) => {
         }
       })(),
 
-      // 热门流派 (Song模型中没有genre字段，返回空数组)
       (async () => {
         return []
       })(),
 
-      // 高峰时段 (最近7天的小时统计)
       (async () => {
         try {
           const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000)
@@ -186,7 +227,6 @@ export default defineEventHandler(async (event) => {
             .from(songs)
             .where(gte(songs.createdAt, sevenDaysAgo))
 
-          // 按小时统计
           const hourCount = songsData.reduce(
             (acc, song) => {
               const hour = getBeijingHour(song.createdAt)
@@ -196,7 +236,6 @@ export default defineEventHandler(async (event) => {
             {} as Record<number, number>
           )
 
-          // 返回前3个高峰时段
           return Object.entries(hourCount)
             .sort(([, a], [, b]) => b - a)
             .slice(0, 3)
@@ -220,8 +259,12 @@ export default defineEventHandler(async (event) => {
       timestamp: now.toISOString()
     }
 
+    await cacheService.setRealtimeStats(result)
+    console.log('[Cache] 实时统计数据已缓存')
+
     return result
   } catch (error) {
+    console.error('[Realtime] 获取失败:', error)
     throw createError({
       statusCode: 500,
       message: '获取实时统计数据失败'

server/api/admin/stats/semester-comparison.get.ts

@@ -4,7 +4,7 @@ import { and, count, db, eq, exists, schedules, semesters, songs, votes } from '
 export default defineEventHandler(async (event) => {
   // 检查认证和权限
   const user = event.context.user
-  if (!user || !['SONG_ADMIN', 'ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
+  if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
     throw createError({
       statusCode: 403,
       message: '需要管理员权限'
@@ -19,28 +19,30 @@ export default defineEventHandler(async (event) => {
     const semesterStats = await Promise.all(
       semesterList.map(async (semester) => {
         // 统计该学期的歌曲数量
-        const totalSongsResult = await db
-          .select({ count: count() })
-          .from(songs)
-          .where(eq(songs.semester, semester.name))
+        const [totalSongsResult, totalSchedulesResult, totalRequestsResult] = await Promise.all([
+          db
+            .select({ count: count() })
+            .from(songs)
+            .where(eq(songs.semester, semester.name)),
 
-        // 统计该学期的排期数量（通过关联歌曲）
-        const totalSchedulesResult = await db
-          .select({ count: count() })
-          .from(schedules)
-          .innerJoin(songs, eq(schedules.songId, songs.id))
-          .where(eq(songs.semester, semester.name))
+          // 统计该学期的排期数量（通过关联歌曲）
+          db
+            .select({ count: count() })
+            .from(schedules)
+            .innerJoin(songs, eq(schedules.songId, songs.id))
+            .where(eq(songs.semester, semester.name)),
 
-        // 统计该学期有投票的歌曲数量
-        const totalRequestsResult = await db
-          .select({ count: count() })
-          .from(songs)
-          .where(
-            and(
-              eq(songs.semester, semester.name),
-              exists(db.select().from(votes).where(eq(votes.songId, songs.id)))
+          // 统计该学期有投票的歌曲数量
+          db
+            .select({ count: count() })
+            .from(songs)
+            .where(
+              and(
+                eq(songs.semester, semester.name),
+                exists(db.select().from(votes).where(eq(votes.songId, songs.id)))
+              )
             )
-          )
+        ])
 
         const [totalSongs, totalSchedules, totalRequests] = [
           totalSongsResult[0]?.count || 0,

server/api/admin/stats/top-songs.get.ts

@@ -1,12 +1,12 @@
 import { createError, defineEventHandler, getQuery } from 'h3'
 import { db } from '~/drizzle/db'
 import { songs, users, votes, songReplayRequests } from '~/drizzle/schema'
-import { count, countDistinct, desc, eq, sql } from 'drizzle-orm'
+import { count, desc, eq, sql } from 'drizzle-orm'
 
 export default defineEventHandler(async (event) => {
   // 检查认证和权限
   const user = event.context.user
-  if (!user || !['SONG_ADMIN', 'ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
+  if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
     throw createError({
       statusCode: 403,
       message: '需要管理员权限'
@@ -30,15 +30,14 @@ export default defineEventHandler(async (event) => {
           artist: songs.artist,
           requesterName: users.name,
           requesterUsername: users.username,
-          // insert-only 模型下同一用户可能有多条申请，按申请人去重计数
-          count: countDistinct(songReplayRequests.userId)
+          count: count(songReplayRequests.id)
         })
         .from(songs)
         .leftJoin(users, eq(songs.requesterId, users.id))
         .leftJoin(songReplayRequests, eq(songs.id, songReplayRequests.songId))
         .where(semester && semester !== 'all' ? eq(songs.semester, semester) : sql`1=1`)
         .groupBy(songs.id, songs.title, songs.artist, users.name, users.username)
-        .orderBy(desc(countDistinct(songReplayRequests.userId)))
+        .orderBy(desc(count(songReplayRequests.id)))
         .limit(limit)
     } else {
       // 按投票数排行（默认）

server/api/admin/stats/trends.get.ts

@@ -5,7 +5,7 @@ import { sql } from 'drizzle-orm'
 export default defineEventHandler(async (event) => {
   // 检查认证和权限
   const user = event.context.user
-  if (!user || !['SONG_ADMIN', 'ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
+  if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
     throw createError({
       statusCode: 403,
       message: '需要管理员权限'

server/api/admin/stats/user-engagement.get.ts

@@ -1,12 +1,12 @@
 import { createError, defineEventHandler, getQuery } from 'h3'
 import { db } from '~/drizzle/db'
 import { songs, users } from '~/drizzle/schema'
-import { and, count, eq, gte, sql } from 'drizzle-orm'
+import { count } from 'drizzle-orm'
 
 export default defineEventHandler(async (event) => {
   // 检查认证和权限
   const user = event.context.user
-  if (!user || !['SONG_ADMIN', 'ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
+  if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
     throw createError({
       statusCode: 403,
       message: '需要管理员权限'
@@ -17,40 +17,47 @@ export default defineEventHandler(async (event) => {
   const semester = query.semester as string
 
   try {
-    const songWhereCondition = semester && semester !== 'all' ? eq(songs.semester, semester) : undefined
+    // 构建查询条件
+    const where = semester && semester !== 'all' ? { semester: semester } : {}
 
     // 获取用户参与度数据
     // 1. 获取总用户数
     const totalUsersResult = await db.select({ count: count() }).from(users)
-    const totalUsers = Number(totalUsersResult[0]?.count || 0)
+    const totalUsers = totalUsersResult[0].count
 
     // 2. 获取有请求歌曲的用户数
-    const activeUsersResult = await db
-      .select({ count: sql<number>`COUNT(DISTINCT ${songs.requesterId})` })
-      .from(songs)
-      .where(songWhereCondition)
-    const activeUsers = Number(activeUsersResult[0]?.count || 0)
+    const allUsers = await db.select().from(users)
+    const allSongs = await db.select().from(songs)
+
+    const activeUsers = allUsers.filter((user) => {
+      return allSongs.some((song) => {
+        if (song.requesterId !== user.id) return false
+        if (semester && semester !== 'all' && song.semester !== semester) return false
+        return true
+      })
+    }).length
 
     // 3. 获取用户请求歌曲的平均数量
-    const totalSongRequestsResult = await db
-      .select({ count: count() })
-      .from(songs)
-      .where(songWhereCondition)
-    const totalSongRequests = Number(totalSongRequestsResult[0]?.count || 0)
+    const userSongCounts = allUsers.map((user) => {
+      const songCount = allSongs.filter((song) => song.requesterId === user.id).length
+      return { ...user, _count: { songs: songCount } }
+    })
+
+    const totalSongRequests = userSongCounts.reduce((sum, user) => sum + user._count.songs, 0)
     const averageSongsPerUser = totalUsers > 0 ? totalSongRequests / totalUsers : 0
 
     // 4. 获取最近活跃用户
     const oneWeekAgo = new Date()
     oneWeekAgo.setDate(oneWeekAgo.getDate() - 7)
 
-    const recentWhereCondition = songWhereCondition
-      ? and(songWhereCondition, gte(songs.createdAt, oneWeekAgo))
-      : gte(songs.createdAt, oneWeekAgo)
-    const recentActiveUsersResult = await db
-      .select({ count: sql<number>`COUNT(DISTINCT ${songs.requesterId})` })
-      .from(songs)
-      .where(recentWhereCondition)
-    const recentActiveUsers = Number(recentActiveUsersResult[0]?.count || 0)
+    const recentActiveUsers = allUsers.filter((user) => {
+      return allSongs.some((song) => {
+        if (song.requesterId !== user.id) return false
+        if (semester && semester !== 'all' && song.semester !== semester) return false
+        if (song.createdAt < oneWeekAgo) return false
+        return true
+      })
+    }).length
 
     return {
       totalUsers,