初次提交

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

@@ -0,0 +1,108 @@
+import { createError, defineEventHandler, getQuery } from 'h3'
+import { db } from '~/drizzle/db'
+import { songs, users, votes } from '~/drizzle/schema'
+import { CacheService } from '../../../services/cacheService'
+
+export default defineEventHandler(async (event) => {
+  // 检查认证和权限
+  const user = event.context.user
+  if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
+    throw createError({
+      statusCode: 403,
+      message: '需要管理员权限'
+    })
+  }
+
+  const query = getQuery(event)
+  const semester = query.semester as string
+  const limit = parseInt(query.limit as string) || 20
+
+  try {
+    // 尝试从缓存获取数据
+    const cacheService = CacheService.getInstance()
+    const cachedStats = await cacheService.getActiveUsersStats(semester, limit)
+    if (cachedStats) {
+      console.log('[Cache] 活跃用户统计数据缓存命中')
+      return cachedStats
+    }
+
+    // 构建查询条件 - 如果没有指定学期或学期为'all'，查询所有用户
+    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 activeUsers = allUsers
+      .filter((user) => {
+        const userSongs = allSongs.filter((song) => {
+          if (song.requesterId !== user.id) return false
+          if (semester && semester !== 'all' && song.semester !== semester) return false
+          return true
+        })
+        return userSongs.length > 0
+      })
+      .map((user) => {
+        const userSongs = allSongs
+          .filter((song) => {
+            if (song.requesterId !== user.id) return false
+            if (semester && semester !== 'all' && song.semester !== semester) return false
+            return true
+          })
+          .map((song) => ({
+            ...song,
+            votes: allVotes.filter((vote) => vote.songId === song.id)
+          }))
+
+        return {
+          ...user,
+          songs: userSongs
+        }
+      })
+
+    // 如果没有活跃用户，返回空数组
+    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 userStat = {
+        id: user.id,
+        name: user.name || user.username, // 优先显示真实姓名，如果没有则显示登录名
+        contributions,
+        likes,
+        activityScore
+      }
+
+      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) {
+    // 返回空数组而不是抛出错误，避免前端显示错误
+    return []
+  }
+})

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

@@ -0,0 +1,191 @@
+import { createError, defineEventHandler } from 'h3'
+import { db } from '~/drizzle/db'
+import { CacheService } from '../../../services/cacheService'
+import { songs, users, votes } from '~/drizzle/schema'
+import { count, eq, gte } from 'drizzle-orm'
+import { getBeijingHour, getBeijingStartOfDay } from '~/utils/timeUtils'
+
+export default defineEventHandler(async (event) => {
+  // 检查认证和权限
+  const user = event.context.user
+  if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
+    throw createError({
+      statusCode: 403,
+      message: '需要管理员权限'
+    })
+  }
+
+  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 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
+            })
+            .from(songs)
+            .innerJoin(users, eq(songs.requesterId, users.id))
+            .where(gte(songs.createdAt, oneHourAgo))
+            .groupBy(songs.requesterId, users.id, users.name, users.username)
+
+          // 获取最近1小时内登录的用户
+          const recentLoginUsers = await db
+            .select({
+              id: users.id,
+              username: users.username,
+              name: users.name
+            })
+            .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
+            })
+            .from(votes)
+            .innerJoin(users, eq(votes.userId, users.id))
+            .where(gte(votes.createdAt, oneHourAgo))
+            .groupBy(votes.userId, users.id, users.name, users.username)
+
+          // 合并并去重用户列表
+          const userMap = new Map()
+
+          // 添加点歌用户
+          recentSongUsers.forEach((song) => {
+            userMap.set(song.requesterId2, {
+              id: song.requesterId2,
+              username: song.requesterUsername,
+              name: song.requesterName
+            })
+          })
+
+          // 添加登录用户
+          recentLoginUsers.forEach((user) => {
+            userMap.set(user.id, {
+              id: user.id,
+              username: user.username,
+              name: user.name
+            })
+          })
+
+          // 添加点赞用户
+          recentVoteUsers.forEach((vote) => {
+            userMap.set(vote.userId2, {
+              id: vote.userId2,
+              username: vote.userUsername,
+              name: vote.userName
+            })
+          })
+
+          const activeUsersList = Array.from(userMap.values())
+
+          return {
+            count: activeUsersList.length,
+            users: activeUsersList
+          }
+        } catch (error) {
+          return {
+            count: 0,
+            users: []
+          }
+        }
+      })(),
+
+      // 今日点歌数
+      (async () => {
+        try {
+          const todayCountResult = await db
+            .select({ count: count() })
+            .from(songs)
+            .where(gte(songs.createdAt, today))
+          return todayCountResult[0].count
+        } catch (error) {
+          return 0
+        }
+      })(),
+
+      // 热门流派 (Song模型中没有genre字段，返回空数组)
+      (async () => {
+        return []
+      })(),
+
+      // 高峰时段 (最近7天的小时统计)
+      (async () => {
+        try {
+          const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000)
+          const songsData = await db
+            .select({
+              createdAt: songs.createdAt
+            })
+            .from(songs)
+            .where(gte(songs.createdAt, sevenDaysAgo))
+
+          // 按小时统计
+          const hourCount = songsData.reduce(
+            (acc, song) => {
+              const hour = getBeijingHour(song.createdAt)
+              acc[hour] = (acc[hour] || 0) + 1
+              return acc
+            },
+            {} as Record<number, number>
+          )
+
+          // 返回前3个高峰时段
+          return Object.entries(hourCount)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 3)
+            .map(([hour, count]) => ({
+              hour: parseInt(hour),
+              count,
+              label: `${hour}:00-${parseInt(hour) + 1}:00`
+            }))
+        } catch (error) {
+          return []
+        }
+      })()
+    ])
+
+    const result = {
+      activeUsers: activeUsersData.count,
+      activeUsersList: activeUsersData.users,
+      todayRequests,
+      popularGenres,
+      peakHours,
+      timestamp: now.toISOString()
+    }
+
+    // 缓存结果
+    await cacheService.setRealtimeStats(result)
+    console.log('[Cache] 实时统计数据已缓存')
+
+    return result
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      message: '获取实时统计数据失败'
+    })
+  }
+})

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

@@ -0,0 +1,71 @@
+import { createError, defineEventHandler } from 'h3'
+import { and, count, db, eq, exists, schedules, semesters, songs, votes } from '~/drizzle/db'
+
+export default defineEventHandler(async (event) => {
+  // 检查认证和权限
+  const user = event.context.user
+  if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
+    throw createError({
+      statusCode: 403,
+      message: '需要管理员权限'
+    })
+  }
+
+  try {
+    // 获取所有学期
+    const semesterList = await db.select().from(semesters).orderBy(semesters.createdAt)
+
+    // 获取每个学期的统计数据
+    const semesterStats = await Promise.all(
+      semesterList.map(async (semester) => {
+        // 统计该学期的歌曲数量
+        const [totalSongsResult, totalSchedulesResult, totalRequestsResult] = await Promise.all([
+          db
+            .select({ count: count() })
+            .from(songs)
+            .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)),
+
+          // 统计该学期有投票的歌曲数量
+          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,
+          totalSchedulesResult[0]?.count || 0,
+          totalRequestsResult[0]?.count || 0
+        ]
+
+        return {
+          semester: semester.name,
+          totalSongs,
+          totalSchedules,
+          totalRequests,
+          isActive: semester.isActive
+        }
+      })
+    )
+
+    return semesterStats
+  } catch (error) {
+    console.error('获取学期对比数据失败:', error)
+    throw createError({
+      statusCode: 500,
+      message: '获取学期对比数据失败'
+    })
+  }
+})

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

@@ -0,0 +1,79 @@
+import { createError, defineEventHandler, getQuery } from 'h3'
+import { db } from '~/drizzle/db'
+import { songs, users, votes, songReplayRequests } from '~/drizzle/schema'
+import { count, desc, eq, sql } from 'drizzle-orm'
+
+export default defineEventHandler(async (event) => {
+  // 检查认证和权限
+  const user = event.context.user
+  if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
+    throw createError({
+      statusCode: 403,
+      message: '需要管理员权限'
+    })
+  }
+
+  const query = getQuery(event)
+  const semester = query.semester as string
+  const limit = parseInt(query.limit as string) || 10
+  const sortBy = (query.sortBy as string) || 'vote'
+
+  try {
+    let topSongs
+
+    if (sortBy === 'replay') {
+      // 按重播次数排行
+      topSongs = await db
+        .select({
+          id: songs.id,
+          title: songs.title,
+          artist: songs.artist,
+          requesterName: users.name,
+          requesterUsername: users.username,
+          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(count(songReplayRequests.id)))
+        .limit(limit)
+    } else {
+      // 按投票数排行（默认）
+      topSongs = await db
+        .select({
+          id: songs.id,
+          title: songs.title,
+          artist: songs.artist,
+          requesterName: users.name,
+          requesterUsername: users.username,
+          count: count(votes.id)
+        })
+        .from(songs)
+        .leftJoin(users, eq(songs.requesterId, users.id))
+        .leftJoin(votes, eq(songs.id, votes.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(count(votes.id)))
+        .limit(limit)
+    }
+
+    // 格式化数据
+    const formattedData = topSongs.map((song) => ({
+      id: song.id,
+      title: song.title,
+      artist: song.artist,
+      count: Number(song.count),
+      requester: song.requesterName || song.requesterUsername || '未知用户'
+    }))
+
+    return formattedData
+  } catch (error) {
+    console.error('获取热门歌曲排行失败:', error)
+    throw createError({
+      statusCode: 500,
+      message: '获取热门歌曲排行失败'
+    })
+  }
+})

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

@@ -0,0 +1,57 @@
+import { createError, defineEventHandler, getQuery } from 'h3'
+import { and, count, db, eq, gte, songs } from '~/drizzle/db'
+import { sql } from 'drizzle-orm'
+
+export default defineEventHandler(async (event) => {
+  // 检查认证和权限
+  const user = event.context.user
+  if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
+    throw createError({
+      statusCode: 403,
+      message: '需要管理员权限'
+    })
+  }
+
+  const query = getQuery(event)
+  const semester = query.semester as string
+
+  try {
+    // 构建查询条件
+    const where = semester && semester !== 'all' ? { semester: semester } : {}
+
+    // 获取最近30天的歌曲点播趋势
+    const thirtyDaysAgo = new Date()
+    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30)
+
+    // 构建where条件
+    let whereCondition = gte(songs.createdAt, thirtyDaysAgo)
+    if (semester && semester !== 'all') {
+      whereCondition = and(whereCondition, eq(songs.semester, semester))
+    }
+
+    // 使用Drizzle ORM的正确语法进行分组查询
+    const trendData = await db
+      .select({
+        date: sql<string>`DATE(${songs.createdAt})`,
+        count: count(songs.id)
+      })
+      .from(songs)
+      .where(whereCondition)
+      .groupBy(sql`DATE(${songs.createdAt})`)
+      .orderBy(sql`DATE(${songs.createdAt}) ASC`)
+
+    // 格式化数据
+    const formattedData = trendData.map((item) => ({
+      date: item.date,
+      count: item.count
+    }))
+
+    return formattedData
+  } catch (error) {
+    console.error('获取趋势数据失败:', error)
+    throw createError({
+      statusCode: 500,
+      message: '获取趋势数据失败'
+    })
+  }
+})

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

@@ -0,0 +1,77 @@
+import { createError, defineEventHandler, getQuery } from 'h3'
+import { db } from '~/drizzle/db'
+import { songs, users } from '~/drizzle/schema'
+import { count } from 'drizzle-orm'
+
+export default defineEventHandler(async (event) => {
+  // 检查认证和权限
+  const user = event.context.user
+  if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
+    throw createError({
+      statusCode: 403,
+      message: '需要管理员权限'
+    })
+  }
+
+  const query = getQuery(event)
+  const semester = query.semester as string
+
+  try {
+    // 构建查询条件
+    const where = semester && semester !== 'all' ? { semester: semester } : {}
+
+    // 获取用户参与度数据
+    // 1. 获取总用户数
+    const totalUsersResult = await db.select({ count: count() }).from(users)
+    const totalUsers = totalUsersResult[0].count
+
+    // 2. 获取有请求歌曲的用户数
+    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 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 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,
+      activeUsers,
+      activeUserPercentage: totalUsers > 0 ? (activeUsers / totalUsers) * 100 : 0,
+      averageSongsPerUser: parseFloat(averageSongsPerUser.toFixed(2)),
+      recentActiveUsers,
+      recentActiveUserPercentage: totalUsers > 0 ? (recentActiveUsers / totalUsers) * 100 : 0
+    }
+  } catch (error) {
+    console.error('获取用户参与度数据失败:', error)
+    throw createError({
+      statusCode: 500,
+      message: '获取用户参与度数据失败'
+    })
+  }
+})