444 lines
15 KiB
TypeScript
444 lines
15 KiB
TypeScript
import { createError, defineEventHandler, getCookie, getHeader, getQuery } from 'h3'
|
||
import jwt from 'jsonwebtoken'
|
||
import { db } from '~/drizzle/db'
|
||
import {
|
||
playTimes,
|
||
schedules,
|
||
songCollaborators,
|
||
songReplayRequests,
|
||
songs,
|
||
systemSettings,
|
||
users,
|
||
votes
|
||
} from '~/drizzle/schema'
|
||
import { and, count, desc, eq, inArray } from 'drizzle-orm'
|
||
import { cacheService } from '~~/server/services/cacheService'
|
||
import { executeRedisCommand, isRedisReady } from '../../utils/redis'
|
||
import { formatDateTime } from '~/utils/timeUtils'
|
||
import { maskPublicScheduleData, PublicScheduleItem } from '../../utils/studentMask'
|
||
|
||
import { verifyUserAuth } from '../../utils/auth'
|
||
|
||
export default defineEventHandler(async (event) => {
|
||
try {
|
||
// 获取查询参数
|
||
const query = getQuery(event)
|
||
const semester = query.semester as string
|
||
const bypassCache = query.bypass_cache === 'true'
|
||
|
||
// 检查用户是否已登录并获取角色
|
||
const authResult = await verifyUserAuth(event)
|
||
const isLoggedIn = authResult.success
|
||
const isAdmin = isLoggedIn && ['ADMIN', 'SUPER_ADMIN', 'SONG_ADMIN'].includes(authResult.user?.role)
|
||
|
||
// 获取系统设置
|
||
const systemSettingsData = await db
|
||
.select()
|
||
.from(systemSettings)
|
||
.limit(1)
|
||
.then((result) => result[0])
|
||
const shouldHideStudentInfo = systemSettingsData?.hideStudentInfo ?? true
|
||
|
||
// 初始化缓存服务
|
||
|
||
// 获取当前日期，使用UTC时间
|
||
const now = new Date()
|
||
const today = new Date(
|
||
Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), 0, 0, 0, 0)
|
||
)
|
||
|
||
// 构建缓存键
|
||
const cacheKey = semester ? `public_schedules:${semester}` : 'public_schedules:all'
|
||
|
||
// 如果不绕过缓存，优先从Redis缓存获取排期数据
|
||
if (!bypassCache && isRedisReady()) {
|
||
const cachedData = await executeRedisCommand(async () => {
|
||
const client = (await import('../../utils/redis')).getRedisClient()
|
||
if (!client) return null
|
||
|
||
const data = await client.get(cacheKey)
|
||
if (data) {
|
||
const parsedData = JSON.parse(data) as PublicScheduleItem[]
|
||
console.log(`[Cache] 公共排期Redis缓存命中: ${cacheKey}，数量: ${parsedData.length}`)
|
||
// 深拷贝数据以避免修改缓存的原始数据
|
||
const resultData = JSON.parse(JSON.stringify(parsedData)) as PublicScheduleItem[]
|
||
// 如果需要隐藏学生信息且用户不是管理员，则对排期数据进行脱敏
|
||
if (shouldHideStudentInfo && !isAdmin) {
|
||
maskPublicScheduleData(resultData)
|
||
}
|
||
return resultData
|
||
}
|
||
|
||
return null
|
||
})
|
||
|
||
if (cachedData) {
|
||
return cachedData
|
||
}
|
||
}
|
||
|
||
// 如果不绕过缓存，Redis缓存未命中，尝试从CacheService获取（CacheService缓存所有学期数据）
|
||
let cachedSchedules = null
|
||
if (!bypassCache) {
|
||
cachedSchedules = await cacheService.getSchedulesList()
|
||
}
|
||
|
||
if (cachedSchedules && cachedSchedules.length > 0) {
|
||
console.log(`[Cache] CacheService排期缓存命中（所有学期），数量: ${cachedSchedules.length}`)
|
||
// 如果指定了学期，过滤数据
|
||
let filteredSchedules = cachedSchedules
|
||
if (semester) {
|
||
filteredSchedules = cachedSchedules.filter((s) => s.song?.semester === semester)
|
||
console.log(`[Cache] 过滤学期 ${semester} 后的数量: ${filteredSchedules.length}`)
|
||
}
|
||
|
||
// 将过滤后的数据缓存到Redis（缓存完整数据，不进行模糊化）
|
||
if (isRedisReady()) {
|
||
await executeRedisCommand(async () => {
|
||
const client = (await import('../../utils/redis')).getRedisClient()
|
||
if (!client) return
|
||
|
||
await client.set(cacheKey, JSON.stringify(filteredSchedules))
|
||
console.log(
|
||
`[Cache] 排期数据设置Redis缓存: ${cacheKey}，数量: ${filteredSchedules.length}`
|
||
)
|
||
})
|
||
}
|
||
|
||
// 深拷贝数据以避免修改缓存的原始数据
|
||
const resultData = JSON.parse(JSON.stringify(filteredSchedules)) as PublicScheduleItem[]
|
||
// 如果需要隐藏学生信息且用户不是管理员，则对排期数据进行脱敏
|
||
if (shouldHideStudentInfo && !isAdmin) {
|
||
maskPublicScheduleData(resultData)
|
||
}
|
||
|
||
return resultData
|
||
}
|
||
|
||
// 获取排期的歌曲，包含播放时段信息（查询所有学期的数据）
|
||
const schedulesData = await db
|
||
.select({
|
||
id: schedules.id,
|
||
playDate: schedules.playDate,
|
||
sequence: schedules.sequence,
|
||
played: schedules.played,
|
||
playTimeId: schedules.playTimeId,
|
||
song: {
|
||
id: songs.id,
|
||
title: songs.title,
|
||
artist: songs.artist,
|
||
played: songs.played,
|
||
cover: songs.cover,
|
||
musicPlatform: songs.musicPlatform,
|
||
musicId: songs.musicId,
|
||
playUrl: songs.playUrl,
|
||
semester: songs.semester,
|
||
requesterId: songs.requesterId,
|
||
createdAt: songs.createdAt
|
||
},
|
||
requester: {
|
||
name: users.name,
|
||
grade: users.grade,
|
||
class: users.class
|
||
},
|
||
playTime: {
|
||
id: playTimes.id,
|
||
name: playTimes.name,
|
||
startTime: playTimes.startTime,
|
||
endTime: playTimes.endTime,
|
||
enabled: playTimes.enabled
|
||
}
|
||
})
|
||
.from(schedules)
|
||
.leftJoin(songs, eq(schedules.songId, songs.id))
|
||
.leftJoin(users, eq(songs.requesterId, users.id))
|
||
.leftJoin(playTimes, eq(schedules.playTimeId, playTimes.id))
|
||
.where(eq(schedules.isDraft, false)) // 只查询已发布的排期
|
||
.orderBy(schedules.playDate)
|
||
|
||
// 获取每首歌的投票数
|
||
const voteCountsQuery = await db
|
||
.select({
|
||
songId: votes.songId,
|
||
count: count(votes.id)
|
||
})
|
||
.from(votes)
|
||
.groupBy(votes.songId)
|
||
|
||
const voteCounts = new Map(voteCountsQuery.map((v) => [v.songId, v.count]))
|
||
|
||
// 获取所有用户的姓名列表，用于检测同名用户
|
||
const allUsers = await db
|
||
.select({
|
||
id: users.id,
|
||
name: users.name,
|
||
grade: users.grade,
|
||
class: users.class
|
||
})
|
||
.from(users)
|
||
|
||
// 创建姓名到用户数组的映射
|
||
const nameToUsers = new Map()
|
||
allUsers.forEach((user) => {
|
||
if (user.name) {
|
||
if (!nameToUsers.has(user.name)) {
|
||
nameToUsers.set(user.name, [])
|
||
}
|
||
nameToUsers.get(user.name).push(user)
|
||
}
|
||
})
|
||
|
||
// 获取联合投稿人信息
|
||
const songIds = schedulesData.map((s) => s.song.id)
|
||
const collaboratorsMap = new Map()
|
||
|
||
if (songIds.length > 0) {
|
||
const collaboratorsData = await db
|
||
.select({
|
||
songId: songCollaborators.songId,
|
||
status: songCollaborators.status,
|
||
user: {
|
||
id: users.id,
|
||
name: users.name,
|
||
grade: users.grade,
|
||
class: users.class
|
||
}
|
||
})
|
||
.from(songCollaborators)
|
||
.leftJoin(users, eq(songCollaborators.userId, users.id))
|
||
.where(
|
||
and(
|
||
inArray(songCollaborators.songId, songIds),
|
||
eq(songCollaborators.status, 'ACCEPTED') // 只展示已接受的
|
||
)
|
||
)
|
||
|
||
collaboratorsData.forEach((c) => {
|
||
if (!collaboratorsMap.has(c.songId)) {
|
||
collaboratorsMap.set(c.songId, [])
|
||
}
|
||
if (c.user) {
|
||
collaboratorsMap.get(c.songId).push(c.user)
|
||
}
|
||
})
|
||
}
|
||
|
||
// 获取重播申请信息
|
||
const replayRequestCountsMap = new Map()
|
||
const replayRequestersMap = new Map()
|
||
|
||
if (songIds.length > 0) {
|
||
// 获取每首歌的重播申请数量（统计 PENDING 和 FULFILLED 状态）
|
||
// FULFILLED 表示已经被排期，PENDING 表示等待排期
|
||
const replayCountsData = await db
|
||
.select({
|
||
songId: songReplayRequests.songId,
|
||
count: count(songReplayRequests.id)
|
||
})
|
||
.from(songReplayRequests)
|
||
.where(
|
||
and(
|
||
inArray(songReplayRequests.songId, songIds),
|
||
// 查询 PENDING 或 FULFILLED 状态的申请
|
||
// PENDING: 等待排期，FULFILLED: 已排期但可能还未播放
|
||
inArray(songReplayRequests.status, ['PENDING', 'FULFILLED'])
|
||
)
|
||
)
|
||
.groupBy(songReplayRequests.songId)
|
||
|
||
replayCountsData.forEach((r) => {
|
||
replayRequestCountsMap.set(r.songId, r.count)
|
||
})
|
||
|
||
// 获取重播申请人列表（前5个，包括 PENDING 和 FULFILLED）
|
||
const replayRequestersData = await db
|
||
.select({
|
||
songId: songReplayRequests.songId,
|
||
user: {
|
||
id: users.id,
|
||
name: users.name,
|
||
grade: users.grade,
|
||
class: users.class
|
||
},
|
||
status: songReplayRequests.status,
|
||
createdAt: songReplayRequests.createdAt
|
||
})
|
||
.from(songReplayRequests)
|
||
.innerJoin(users, eq(songReplayRequests.userId, users.id))
|
||
.where(
|
||
and(
|
||
inArray(songReplayRequests.songId, songIds),
|
||
inArray(songReplayRequests.status, ['PENDING', 'FULFILLED'])
|
||
)
|
||
)
|
||
.orderBy(desc(songReplayRequests.createdAt))
|
||
|
||
replayRequestersData.forEach((r) => {
|
||
if (!replayRequestersMap.has(r.songId)) {
|
||
replayRequestersMap.set(r.songId, [])
|
||
}
|
||
// 只保留前5个
|
||
if (replayRequestersMap.get(r.songId).length < 5) {
|
||
replayRequestersMap.get(r.songId).push({
|
||
id: r.user.id,
|
||
name: r.user.name || '未知用户',
|
||
grade: r.user.grade,
|
||
class: r.user.class,
|
||
status: r.status
|
||
})
|
||
}
|
||
})
|
||
}
|
||
|
||
// 辅助函数：格式化显示名称
|
||
const formatDisplayName = (userObj: any) => {
|
||
if (!userObj || !userObj.name) return '未知用户'
|
||
let displayName = userObj.name
|
||
|
||
const sameNameUsers = nameToUsers.get(displayName)
|
||
if (sameNameUsers && sameNameUsers.length > 1) {
|
||
if (userObj.grade) {
|
||
const sameGradeUsers = sameNameUsers.filter((u: any) => u.grade === userObj.grade)
|
||
if (sameGradeUsers.length > 1 && userObj.class) {
|
||
displayName = `${displayName}（${userObj.grade} ${userObj.class}）`
|
||
} else {
|
||
displayName = `${displayName}（${userObj.grade}）`
|
||
}
|
||
}
|
||
}
|
||
return displayName
|
||
}
|
||
|
||
// 转换数据格式
|
||
const formattedSchedules = schedulesData.map((schedule) => {
|
||
// 获取原始日期，并确保使用UTC时间
|
||
const originalDate = new Date(schedule.playDate)
|
||
|
||
// 创建一个新的日期对象，保留原始日期的年月日，但使用UTC时间
|
||
const dateOnly = new Date(
|
||
Date.UTC(
|
||
originalDate.getUTCFullYear(),
|
||
originalDate.getUTCMonth(),
|
||
originalDate.getUTCDate(),
|
||
0,
|
||
0,
|
||
0,
|
||
0
|
||
)
|
||
)
|
||
|
||
// 处理投稿人姓名
|
||
const requesterName = formatDisplayName(schedule.requester)
|
||
|
||
// 处理联合投稿人
|
||
const collaborators = collaboratorsMap.get(schedule.song.id) || []
|
||
const formattedCollaborators = collaborators.map((c: any) => ({
|
||
id: c.id,
|
||
name: c.name,
|
||
displayName: formatDisplayName(c),
|
||
grade: c.grade,
|
||
class: c.class
|
||
}))
|
||
|
||
// 获取重播申请信息
|
||
const replayRequestCount = replayRequestCountsMap.get(schedule.song.id) || 0
|
||
const replayRequesters = replayRequestersMap.get(schedule.song.id) || []
|
||
const formattedReplayRequesters = replayRequesters.map((r: any) => ({
|
||
id: r.id,
|
||
name: r.name,
|
||
displayName: formatDisplayName(r),
|
||
grade: r.grade,
|
||
class: r.class,
|
||
status: r.status
|
||
}))
|
||
|
||
// 判断是否为重播：有重播申请（PENDING 或 FULFILLED）
|
||
const isReplaySong = replayRequestCount > 0
|
||
|
||
// 注意：这里不进行模糊化处理，保持完整数据用于缓存
|
||
// 模糊化处理将在最终返回时进行
|
||
|
||
return {
|
||
id: schedule.id,
|
||
playDate: dateOnly.toISOString().split('T')[0], // 转换为YYYY-MM-DD格式字符串
|
||
sequence: schedule.sequence || 1,
|
||
played: schedule.played || false,
|
||
playTimeId: schedule.playTimeId, // 添加播放时段ID
|
||
playTime: schedule.playTime
|
||
? {
|
||
id: schedule.playTime.id,
|
||
name: schedule.playTime.name,
|
||
startTime: schedule.playTime.startTime,
|
||
endTime: schedule.playTime.endTime,
|
||
enabled: schedule.playTime.enabled
|
||
}
|
||
: null, // 添加播放时段信息
|
||
song: {
|
||
id: schedule.song.id,
|
||
title: schedule.song.title,
|
||
artist: schedule.song.artist,
|
||
requester: requesterName,
|
||
requesterGrade: schedule.requester?.grade || null,
|
||
requesterClass: schedule.requester?.class || null,
|
||
collaborators: formattedCollaborators, // 添加联合投稿人
|
||
voteCount: voteCounts.get(schedule.song.id) || 0,
|
||
played: schedule.song.played || false,
|
||
cover: schedule.song.cover || null,
|
||
musicPlatform: schedule.song.musicPlatform || null,
|
||
musicId: schedule.song.musicId || null,
|
||
playUrl: schedule.song.playUrl || null,
|
||
semester: schedule.song.semester || null,
|
||
requestedAt: schedule.song.createdAt ? formatDateTime(schedule.song.createdAt) : null,
|
||
// 重播申请信息
|
||
replayRequestCount: isReplaySong ? replayRequestCount : 0,
|
||
replayRequesters: isReplaySong ? formattedReplayRequesters : [],
|
||
isReplay: isReplaySong // 只有已播放过且有重播申请的才标记为重播
|
||
}
|
||
}
|
||
})
|
||
|
||
const allSchedulesResult = formattedSchedules
|
||
|
||
// 始终缓存所有学期的数据到CacheService
|
||
if (allSchedulesResult && allSchedulesResult.length > 0) {
|
||
await cacheService.setSchedulesList(allSchedulesResult)
|
||
console.log(
|
||
`[Cache] 公共排期设置CacheService缓存（所有学期），数量: ${allSchedulesResult.length}`
|
||
)
|
||
}
|
||
|
||
// 准备要返回和缓存的数据
|
||
let finalResult = allSchedulesResult
|
||
if (semester && allSchedulesResult) {
|
||
finalResult = allSchedulesResult.filter((s) => s.song?.semester === semester)
|
||
}
|
||
|
||
// 缓存结果到Redis（如果可用）- 根据请求参数缓存相应数据
|
||
if (finalResult && isRedisReady()) {
|
||
await executeRedisCommand(async () => {
|
||
const client = (await import('../../utils/redis')).getRedisClient()
|
||
if (!client) return
|
||
|
||
await client.set(cacheKey, JSON.stringify(finalResult))
|
||
console.log(`[Cache] 排期数据设置Redis缓存: ${cacheKey}，数量: ${finalResult.length}`)
|
||
})
|
||
}
|
||
|
||
// 深拷贝数据以避免修改缓存的原始数据
|
||
const resultToReturn = JSON.parse(JSON.stringify(finalResult || allSchedulesResult)) as PublicScheduleItem[]
|
||
|
||
// 如果需要隐藏学生信息且用户不是管理员，则对排期数据进行脱敏
|
||
if (shouldHideStudentInfo && !isAdmin && resultToReturn) {
|
||
maskPublicScheduleData(resultToReturn)
|
||
}
|
||
|
||
return resultToReturn
|
||
} catch (error: any) {
|
||
console.error('获取公共排期失败:', error)
|
||
throw createError({
|
||
statusCode: 500,
|
||
statusMessage: error.message || '获取排期数据失败'
|
||
})
|
||
}
|
||
})
|