273 lines
8.1 KiB
TypeScript
273 lines
8.1 KiB
TypeScript
import { db } from '~/drizzle/db'
|
|
import { schedules, songReplayRequests, songs, users, votes } from '~/drizzle/schema'
|
|
import { and, count, desc, eq, inArray } from 'drizzle-orm'
|
|
|
|
export default defineEventHandler(async (event) => {
|
|
try {
|
|
// 使用认证中间件提供的用户信息
|
|
const currentUser = event.context.user
|
|
if (!currentUser) {
|
|
throw createError({
|
|
statusCode: 401,
|
|
statusMessage: '未授权访问'
|
|
})
|
|
}
|
|
|
|
// 检查是否为管理员、歌曲管理员或超级管理员
|
|
const allowedRoles = ['ADMIN', 'SONG_ADMIN', 'SUPER_ADMIN']
|
|
if (!allowedRoles.includes(currentUser.role)) {
|
|
throw createError({
|
|
statusCode: 403,
|
|
statusMessage: '权限不足'
|
|
})
|
|
}
|
|
|
|
// 获取用户ID
|
|
const userId = parseInt(getRouterParam(event, 'id') as string)
|
|
if (!userId || isNaN(userId)) {
|
|
throw createError({
|
|
statusCode: 400,
|
|
statusMessage: '无效的用户ID'
|
|
})
|
|
}
|
|
|
|
// 验证用户是否存在
|
|
const userResult = await db
|
|
.select({
|
|
id: users.id,
|
|
name: users.name,
|
|
username: users.username,
|
|
grade: users.grade,
|
|
class: users.class
|
|
})
|
|
.from(users)
|
|
.where(eq(users.id, userId))
|
|
.limit(1)
|
|
|
|
const user = userResult[0]
|
|
|
|
if (!user) {
|
|
throw createError({
|
|
statusCode: 404,
|
|
statusMessage: '用户不存在'
|
|
})
|
|
}
|
|
|
|
// 获取用户投稿的歌曲
|
|
const submittedSongs = await db
|
|
.select({
|
|
id: songs.id,
|
|
title: songs.title,
|
|
artist: songs.artist,
|
|
semester: songs.semester,
|
|
createdAt: songs.createdAt,
|
|
played: songs.played
|
|
})
|
|
.from(songs)
|
|
.where(eq(songs.requesterId, userId))
|
|
.orderBy(desc(songs.createdAt))
|
|
|
|
// 获取投稿歌曲的投票数
|
|
const submittedSongIds = submittedSongs.map((song) => song.id)
|
|
const submittedVoteCountsMap = new Map()
|
|
if (submittedSongIds.length > 0) {
|
|
const submittedVoteCountsResult = await db
|
|
.select({
|
|
songId: votes.songId,
|
|
voteCount: count(votes.id)
|
|
})
|
|
.from(votes)
|
|
.where(inArray(votes.songId, submittedSongIds))
|
|
.groupBy(votes.songId)
|
|
|
|
submittedVoteCountsResult.forEach((item) => {
|
|
submittedVoteCountsMap.set(item.songId, item.voteCount)
|
|
})
|
|
}
|
|
|
|
// 获取用户投票的歌曲
|
|
const votedSongs = await db
|
|
.select({
|
|
id: votes.id,
|
|
createdAt: votes.createdAt,
|
|
songId: votes.songId,
|
|
songTitle: songs.title,
|
|
songArtist: songs.artist,
|
|
songSemester: songs.semester,
|
|
songPlayed: songs.played,
|
|
requesterName: users.name,
|
|
requesterGrade: users.grade,
|
|
requesterClass: users.class
|
|
})
|
|
.from(votes)
|
|
.leftJoin(songs, eq(votes.songId, songs.id))
|
|
.leftJoin(users, eq(songs.requesterId, users.id))
|
|
.where(eq(votes.userId, userId))
|
|
.orderBy(desc(votes.createdAt))
|
|
|
|
// 获取投票歌曲的投票数
|
|
const votedSongIds = votedSongs.map((vote) => vote.songId).filter((id) => id !== null)
|
|
const votedVoteCountsMap = new Map()
|
|
if (votedSongIds.length > 0) {
|
|
const votedVoteCountsResult = await db
|
|
.select({
|
|
songId: votes.songId,
|
|
voteCount: count(votes.id)
|
|
})
|
|
.from(votes)
|
|
.where(inArray(votes.songId, votedSongIds))
|
|
.groupBy(votes.songId)
|
|
|
|
votedVoteCountsResult.forEach((item) => {
|
|
votedVoteCountsMap.set(item.songId, item.voteCount)
|
|
})
|
|
}
|
|
|
|
// 获取投稿歌曲的排期状态
|
|
// 只查询已发布的排期，草稿不算作已排期
|
|
const submittedScheduleMap = new Map()
|
|
if (submittedSongIds.length > 0) {
|
|
const submittedScheduleResult = await db
|
|
.select({
|
|
songId: schedules.songId
|
|
})
|
|
.from(schedules)
|
|
.where(and(inArray(schedules.songId, submittedSongIds), eq(schedules.isDraft, false)))
|
|
|
|
submittedScheduleResult.forEach((item) => {
|
|
submittedScheduleMap.set(item.songId, true)
|
|
})
|
|
}
|
|
|
|
// 获取投票歌曲的排期状态
|
|
// 只查询已发布的排期，草稿不算作已排期
|
|
const votedScheduleMap = new Map()
|
|
if (votedSongIds.length > 0) {
|
|
const votedScheduleResult = await db
|
|
.select({
|
|
songId: schedules.songId
|
|
})
|
|
.from(schedules)
|
|
.where(and(inArray(schedules.songId, votedSongIds), eq(schedules.isDraft, false)))
|
|
|
|
votedScheduleResult.forEach((item) => {
|
|
votedScheduleMap.set(item.songId, true)
|
|
})
|
|
}
|
|
|
|
// 获取用户申请重播的歌曲
|
|
const replayRequestedSongs = await db
|
|
.select({
|
|
id: songReplayRequests.id,
|
|
createdAt: songReplayRequests.createdAt,
|
|
songId: songReplayRequests.songId,
|
|
songTitle: songs.title,
|
|
songArtist: songs.artist,
|
|
songSemester: songs.semester,
|
|
songPlayed: songs.played,
|
|
requesterName: users.name,
|
|
requesterGrade: users.grade,
|
|
requesterClass: users.class
|
|
})
|
|
.from(songReplayRequests)
|
|
.leftJoin(songs, eq(songReplayRequests.songId, songs.id))
|
|
.leftJoin(users, eq(songs.requesterId, users.id))
|
|
.where(eq(songReplayRequests.userId, userId))
|
|
.orderBy(desc(songReplayRequests.createdAt))
|
|
|
|
// 获取重播申请歌曲的总申请数
|
|
const replaySongIds = replayRequestedSongs.map((req) => req.songId).filter((id) => id !== null)
|
|
const replayRequestCountsMap = new Map()
|
|
if (replaySongIds.length > 0) {
|
|
const replayRequestCountsResult = await db
|
|
.select({
|
|
songId: songReplayRequests.songId,
|
|
requestCount: count(songReplayRequests.id)
|
|
})
|
|
.from(songReplayRequests)
|
|
.where(inArray(songReplayRequests.songId, replaySongIds))
|
|
.groupBy(songReplayRequests.songId)
|
|
|
|
replayRequestCountsResult.forEach((item) => {
|
|
replayRequestCountsMap.set(item.songId, item.requestCount)
|
|
})
|
|
}
|
|
|
|
// 获取重播申请歌曲的排期状态
|
|
const replayScheduleMap = new Map()
|
|
if (replaySongIds.length > 0) {
|
|
const replayScheduleResult = await db
|
|
.select({
|
|
songId: schedules.songId
|
|
})
|
|
.from(schedules)
|
|
.where(and(inArray(schedules.songId, replaySongIds), eq(schedules.isDraft, false)))
|
|
|
|
replayScheduleResult.forEach((item) => {
|
|
replayScheduleMap.set(item.songId, true)
|
|
})
|
|
}
|
|
|
|
return {
|
|
user: {
|
|
id: user.id,
|
|
name: user.name,
|
|
username: user.username,
|
|
grade: user.grade,
|
|
class: user.class
|
|
},
|
|
submittedSongs: submittedSongs.map((song) => ({
|
|
id: song.id,
|
|
title: song.title,
|
|
artist: song.artist,
|
|
semester: song.semester,
|
|
createdAt: song.createdAt,
|
|
played: song.played,
|
|
scheduled: submittedScheduleMap.has(song.id),
|
|
voteCount: submittedVoteCountsMap.get(song.id) || 0
|
|
})),
|
|
votedSongs: votedSongs.map((vote) => ({
|
|
id: vote.songId,
|
|
title: vote.songTitle,
|
|
artist: vote.songArtist,
|
|
semester: vote.songSemester,
|
|
played: vote.songPlayed,
|
|
scheduled: votedScheduleMap.has(vote.songId),
|
|
voteCount: votedVoteCountsMap.get(vote.songId) || 0,
|
|
votedAt: vote.createdAt,
|
|
requester: {
|
|
name: vote.requesterName,
|
|
grade: vote.requesterGrade,
|
|
class: vote.requesterClass
|
|
}
|
|
})),
|
|
replayRequestedSongs: replayRequestedSongs.map((req) => ({
|
|
id: req.songId,
|
|
title: req.songTitle,
|
|
artist: req.songArtist,
|
|
semester: req.songSemester,
|
|
played: req.songPlayed,
|
|
scheduled: replayScheduleMap.has(req.songId),
|
|
requestCount: replayRequestCountsMap.get(req.songId) || 0,
|
|
requestedAt: req.createdAt,
|
|
requester: {
|
|
name: req.requesterName,
|
|
grade: req.requesterGrade,
|
|
class: req.requesterClass
|
|
}
|
|
}))
|
|
}
|
|
} catch (error) {
|
|
console.error('获取用户歌曲信息失败:', error)
|
|
|
|
if (error.statusCode) {
|
|
throw error
|
|
}
|
|
|
|
throw createError({
|
|
statusCode: 500,
|
|
statusMessage: '服务器内部错误'
|
|
})
|
|
}
|
|
})
|