235 lines
7.0 KiB
TypeScript
235 lines
7.0 KiB
TypeScript
import { z } from 'zod'
|
|
import { db } from '~/drizzle/db'
|
|
import { CacheService } from '~~/server/services/cacheService'
|
|
import { users, userStatusLogs } from '~/drizzle/schema'
|
|
import { and, eq, inArray, ne } from 'drizzle-orm'
|
|
|
|
// 请求体验证模式
|
|
const batchUpdateSchema = z.object({
|
|
updates: z
|
|
.array(
|
|
z.object({
|
|
userId: z.number().int().positive(),
|
|
grade: z.string().optional(),
|
|
class: z.string().optional(),
|
|
username: z.string().optional(),
|
|
status: z.enum(['active', 'withdrawn', 'graduate']).optional()
|
|
})
|
|
)
|
|
.min(1)
|
|
.max(100) // 限制批量更新数量
|
|
})
|
|
|
|
export default defineEventHandler(async (event) => {
|
|
try {
|
|
// 使用认证中间件提供的用户信息
|
|
const currentUser = event.context.user
|
|
|
|
if (!currentUser) {
|
|
throw createError({
|
|
statusCode: 401,
|
|
statusMessage: 'Authentication required'
|
|
})
|
|
}
|
|
|
|
// 检查权限 - 只有管理员和超级管理员可以执行批量更新
|
|
if (!['ADMIN', 'SUPER_ADMIN'].includes(currentUser.role)) {
|
|
throw createError({
|
|
statusCode: 403,
|
|
statusMessage: 'Insufficient permissions'
|
|
})
|
|
}
|
|
|
|
// 验证请求体
|
|
const body = await readBody(event)
|
|
const validationResult = batchUpdateSchema.safeParse(body)
|
|
|
|
if (!validationResult.success) {
|
|
throw createError({
|
|
statusCode: 400,
|
|
statusMessage:
|
|
'请求参数无效: ' + validationResult.error.errors.map((e) => e.message).join(', ')
|
|
})
|
|
}
|
|
|
|
const { updates } = validationResult.data
|
|
|
|
// 获取所有要更新的用户ID
|
|
const userIds = updates.map((update) => update.userId)
|
|
|
|
// 验证用户是否存在且为学生角色
|
|
const existingUsers = await db
|
|
.select({
|
|
id: users.id,
|
|
name: users.name,
|
|
username: users.username,
|
|
role: users.role,
|
|
status: users.status
|
|
})
|
|
.from(users)
|
|
.where(and(inArray(users.id, userIds), eq(users.role, 'USER')))
|
|
|
|
// 检查是否所有用户都存在且为学生
|
|
const existingUserIds = new Set(existingUsers.map((user) => user.id))
|
|
const missingUserIds = userIds.filter((id) => !existingUserIds.has(id))
|
|
|
|
if (missingUserIds.length > 0) {
|
|
throw createError({
|
|
statusCode: 400,
|
|
statusMessage: `以下用户ID不存在或不是学生: ${missingUserIds.join(', ')}`
|
|
})
|
|
}
|
|
|
|
// 执行批量更新
|
|
const updateResults = []
|
|
const errors = []
|
|
|
|
for (const update of updates) {
|
|
try {
|
|
// 禁止批量更新包含当前操作者自身
|
|
if (update.userId === currentUser.id) {
|
|
errors.push({
|
|
userId: update.userId,
|
|
error: '禁止在用户管理中批量更新自己的账户'
|
|
})
|
|
continue
|
|
}
|
|
// 构建更新数据
|
|
const updateData: any = {}
|
|
|
|
if (update.grade !== undefined && update.grade.trim()) {
|
|
updateData.grade = update.grade.trim()
|
|
}
|
|
|
|
if (update.class !== undefined && update.class.trim()) {
|
|
updateData.class = update.class.trim()
|
|
}
|
|
|
|
// 处理用户名更新
|
|
if (update.username !== undefined && update.username.trim()) {
|
|
const newUsername = update.username.trim()
|
|
|
|
// 检查用户名是否已存在（排除当前用户）
|
|
const existingUser = await db
|
|
.select({ id: users.id })
|
|
.from(users)
|
|
.where(and(eq(users.username, newUsername), ne(users.id, update.userId)))
|
|
.limit(1)
|
|
|
|
if (existingUser.length > 0) {
|
|
errors.push({
|
|
userId: update.userId,
|
|
error: `用户名 "${newUsername}" 已存在`
|
|
})
|
|
continue
|
|
}
|
|
|
|
updateData.username = newUsername
|
|
}
|
|
|
|
if (update.status !== undefined) {
|
|
const currentUserStatus = existingUsers.find((u) => u.id === update.userId)?.status
|
|
if (update.status !== currentUserStatus) {
|
|
updateData.status = update.status
|
|
updateData.statusChangedAt = new Date()
|
|
updateData.statusChangedBy = currentUser.id
|
|
}
|
|
}
|
|
|
|
// 如果没有要更新的字段，跳过
|
|
if (Object.keys(updateData).length === 0) {
|
|
continue
|
|
}
|
|
|
|
let updatedUser
|
|
|
|
// 使用事务确保更新和日志记录的原子性
|
|
await db.transaction(async (tx) => {
|
|
// 更新用户信息
|
|
const updatedUserResult = await tx
|
|
.update(users)
|
|
.set(updateData)
|
|
.where(eq(users.id, update.userId))
|
|
.returning({
|
|
id: users.id,
|
|
name: users.name,
|
|
username: users.username,
|
|
grade: users.grade,
|
|
class: users.class,
|
|
status: users.status
|
|
})
|
|
|
|
updatedUser = updatedUserResult[0]
|
|
|
|
// 记录状态变更日志
|
|
if (updateData.status) {
|
|
const currentUserStatus = existingUsers.find((u) => u.id === update.userId)?.status
|
|
await tx.insert(userStatusLogs).values({
|
|
userId: update.userId,
|
|
oldStatus: currentUserStatus,
|
|
newStatus: updateData.status,
|
|
reason: `管理员${currentUser.name || currentUser.username}批量更新用户状态`,
|
|
operatorId: currentUser.id,
|
|
createdAt: new Date()
|
|
})
|
|
}
|
|
})
|
|
|
|
updateResults.push(updatedUser)
|
|
} catch (error) {
|
|
console.error(`处理用户 ${update.userId} 更新时出错:`, error)
|
|
errors.push({
|
|
userId: update.userId,
|
|
error: error.message || '未知错误'
|
|
})
|
|
}
|
|
}
|
|
|
|
// 返回结果
|
|
const response = {
|
|
success: true,
|
|
message: `批量更新完成，成功更新 ${updateResults.length} 个用户`,
|
|
data: {
|
|
updated: updateResults,
|
|
errors: errors,
|
|
summary: {
|
|
total: updates.length,
|
|
success: updateResults.length,
|
|
failed: errors.length
|
|
}
|
|
}
|
|
}
|
|
|
|
// 如果有部分失败，调整消息
|
|
if (errors.length > 0) {
|
|
response.message = `批量更新部分完成，成功更新 ${updateResults.length} 个用户，${errors.length} 个用户更新失败`
|
|
}
|
|
|
|
// 如果有用户更新成功，清除相关缓存
|
|
if (updateResults.length > 0) {
|
|
try {
|
|
const cacheService = CacheService.getInstance()
|
|
await cacheService.clearSongsCache()
|
|
console.log('批量用户更新后缓存清除成功')
|
|
} catch (cacheError) {
|
|
console.error('批量用户更新后缓存清除失败:', cacheError)
|
|
}
|
|
}
|
|
|
|
return response
|
|
} catch (error) {
|
|
console.error('批量更新用户失败:', error)
|
|
|
|
// 如果是已知错误，直接抛出
|
|
if (error.statusCode) {
|
|
throw error
|
|
}
|
|
|
|
// 未知错误
|
|
throw createError({
|
|
statusCode: 500,
|
|
statusMessage: '批量更新用户失败: ' + error.message
|
|
})
|
|
}
|
|
})
|